pxv6y92jf
/
banban
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: pxv6y92jf:main
Branches Tags
pxv6y92jf:xqr
pxv6y92jf:main
pxv6y92jf:cw
pxv6y92jf:master
pxv6y92jf:zwk
pxv6y92jf:hzy
..
compare: pxv6y92jf:xqr
Branches Tags
pxv6y92jf:xqr
pxv6y92jf:main
pxv6y92jf:cw
pxv6y92jf:master
pxv6y92jf:zwk
pxv6y92jf:hzy

1 Commits
main ... xqr

Author SHA1 Message Date
pjxtpl2cb 5293eb3e78 Add MovieMapper
1 year ago
40 changed files with 3049 additions and 4570 deletions
Show Stats

647
MovieMapper
Unescape View File

@ -0,0 +1,647 @@
/*
Navicat Premium Data Transfer
Source Server : localhost_3306
Source Server Type : MySQL
Source Server Version : 80012
Source Host : localhost:3306
Source Schema : movie
Target Server Type : MySQL
Target Server Version : 80012
File Encoding : 65001
Date: 06/08/2019 14:40:26
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for cinema
-- ----------------------------
DROP TABLE IF EXISTS `cinema`;
CREATE TABLE `cinema` (
`cinema_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT '影院编号',
`cinema_name` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '影院名称',
`cinema_address` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '影院地址',
PRIMARY KEY (`cinema_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 19 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of cinema
-- ----------------------------
INSERT INTO `cinema` VALUES (1, '中山奇幻电影院', '石岐区岐头新村龙凤街4号大信溢彩荟二期8楼');
INSERT INTO `cinema` VALUES (2, '金逸影城中山石歧店', '石岐区大信南路2路大信新都汇5楼');
INSERT INTO `cinema` VALUES (3, '博纳国际影城（中山IMAX店）', '古镇区同兴路98号利和广场购物中心四楼4009号');
INSERT INTO `cinema` VALUES (4, 'UME影城（中山古镇店）', '古镇区中兴大道南一号花艺广场11层A区');
INSERT INTO `cinema` VALUES (5, '中影100影城石歧店', '石岐区康华路15号恒基大厦3楼');
INSERT INTO `cinema` VALUES (6, '橙天嘉禾影城（利和店）', '石岐区中山三路16号利和广场五层');
INSERT INTO `cinema` VALUES (7, '珠影GCC影城（中山杜比全景声店）', '火炬高技术产业开发区火炬开发区港城路7号明珠广场二期');
INSERT INTO `cinema` VALUES (8, '期遇·翼影城（东凤店）', '东凤镇东富路81号大顺时尚荟广场B座四楼（原君信大厦）');
INSERT INTO `cinema` VALUES (9, '中山IM电影城（南朗壹加壹店）', '南朗镇岭南路62号新壹加壹4楼');
INSERT INTO `cinema` VALUES (10, '艺达国际影城（小榄杜比全景声店）', '小榄镇新华中路118号大信新都汇118广场4楼');
INSERT INTO `cinema` VALUES (11, '中影天乐电影城（海州汇海城店）', '古镇镇古镇海州市场汇海城北门电梯5楼（星海湾对面）');
INSERT INTO `cinema` VALUES (12, '比高电影城（中山店）', '坦洲镇坦神北路118号皇爵假日广场4楼');
INSERT INTO `cinema` VALUES (13, '大地影院（星宝时代店）', '沙溪镇乐群坎溪村（星宝路6号星宝时代广场）');
INSERT INTO `cinema` VALUES (14, '中影星艺影城（南朗车站店）', '南朗镇南朗车站2楼');
INSERT INTO `cinema` VALUES (15, '中影太阳城影院（张家边店）', '火炬高技术产业开发区东镇东一路23号太阳城购物中心4楼（近群英华庭）');
INSERT INTO `cinema` VALUES (16, '五月花电影城（棕榈彩虹商业中心店）', '西区街道棕榈彩虹商业中心1座三楼（近新中医院）');
INSERT INTO `cinema` VALUES (17, '高菲影城（中山万益广场店）', '板芙镇迎宾大道8号（万益广场店）');
INSERT INTO `cinema` VALUES (18, '金逸影城（中山远洋城IMAX店）', '东区街道博爱六路28号远洋广场3幢大信新都汇4楼');
-- ----------------------------
-- Table structure for comment
-- ----------------------------
DROP TABLE IF EXISTS `comment`;
CREATE TABLE `comment` (
`comment_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT '评论编号',
`user_id` bigint(10) NOT NULL COMMENT '所属用户编号',
`comment_content` varchar(150) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '评论内容',
`movie_id` bigint(10) NOT NULL COMMENT '所属电影编号',
`comment_time` datetime(0) NOT NULL COMMENT '评论时间',
PRIMARY KEY (`comment_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 58 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of comment
-- ----------------------------
INSERT INTO `comment` VALUES (3, 1, '不容错过', 3, '2019-07-18 15:15:22');
INSERT INTO `comment` VALUES (4, 1, '车开电车侧壁如履平地，足踢卫星返回舱一脚拯救东京，我看柯南跟吴京此生必有一战吧', 4, '2019-07-13 11:15:01');
INSERT INTO `comment` VALUES (5, 1, '看到最后一直在想真正的主角【皮球】怎么还不登场，结果果然没有让我失望。哦对，主役是皮球的话，二番就是安室的车了吧。', 5, '2019-07-13 11:15:14');
INSERT INTO `comment` VALUES (7, 1, '东南亚电影院的观众们同时发出了杠铃般的笑声4536346', 7, '2019-07-24 02:37:36');
INSERT INTO `comment` VALUES (8, 1, '谁要看你们检察院公安撕逼 我操 还我黑衣人组织', 8, '2019-07-13 11:15:51');
INSERT INTO `comment` VALUES (10, 1, '还行，没吹得那么好，有点像强化娱乐性的海底版《黑豹》...故事线极其简单，打戏遍布扩成了143分钟的篇幅，对路人非常友好，不过这类过度炫目眼花缭乱的特效已经越看越麻木，什么海底《阿凡达》吹太过了，坐等《阿凡达2》的潘多拉海底世界吊打吧', 10, '2019-07-13 11:16:34');
INSERT INTO `comment` VALUES (11, 2, '我是admin欢迎大家评论哦', 1, '2019-07-17 16:59:56');
INSERT INTO `comment` VALUES (12, 2, '女王：维科，这是我大儿子，剩下的话不用我多说了吧，以后该怎么办，你自己招子放亮一点，好处不会少了你的。维科：晓得了。zz4124', 2, '2019-07-24 02:34:15');
INSERT INTO `comment` VALUES (13, 2, '东有沉香劈山救母，西有海娃寻叉救母。绿色秋裤哲学变身，刺身放题海底大战。同母异父兄弟相残，弟妹大伯不伦之恋。温子仁携手徐锦江，亚裔之光拯救好莱坞！', 3, '2019-07-13 11:28:40');
INSERT INTO `comment` VALUES (14, 2, '2.5 “我的恋人，就是这个国家啊！”———————好久没有听到这么烂的话了', 4, '2019-07-13 11:33:21');
INSERT INTO `comment` VALUES (15, 2, '今年的柯南剧场版好无聊啊。。后面那段飙车简直夸张到无法理解，故事最后的反转也很让人无语，完全是多此一举，没有好的剧本就别拍了好吗，估计上映了也捞不到太多票房。ps:韩语版的柯南真的让人看得别扭不舒服..', 5, '2019-07-13 11:35:46');
INSERT INTO `comment` VALUES (16, 2, '渔夫和灯塔守护多数是鳏夫，私下里经常养一些人鱼交欢。海洋远比陆地深远得多，人们赞美阳光下的海洋，却不知深夜降临海面上会冒出可怕的妖怪，海底也会藏着嘲笑人类的高级文明。所以！温子仁同样是一个借大热系列ip来讲自己故事的导演！', 6, '2019-07-13 11:36:08');
INSERT INTO `comment` VALUES (17, 2, '海王可能要被微博营销号给奶死了。。。', 7, '2019-07-13 11:36:14');
INSERT INTO `comment` VALUES (18, 2, '当陆地人为自己的文明沾沾自喜时，亚特兰蒂斯的服装设计已经领先我们几百年。', 8, '2019-07-13 11:36:41');
INSERT INTO `comment` VALUES (19, 2, '温子仁就像一个从没拍过特效大片的暴发户。两星半，降降火。', 9, '2019-07-13 11:36:50');
INSERT INTO `comment` VALUES (20, 2, '剧本，导演都有问题，很多片段都似曾相识，硬是凑了两个半小时真是辛苦了我的膀胱。然而剧情不够美工来凑，海底阿凡达，温子仁难担大任，DC要超越漫威还有很长的路要走。', 10, '2019-07-13 11:36:58');
INSERT INTO `comment` VALUES (22, 3, '前面的小男孩突然问起诉是什么意思，我就在想这个故事小孩看得懂吗？动作场景依然需要帮忙按住牛顿的棺材板。', 4, '2019-07-13 11:37:43');
INSERT INTO `comment` VALUES (23, 3, '7分。温子仁确实很厉害，原以为这该是系列中最无趣的一部，尤其各种水下戏份。结果，却难得拍的很好看。影片节奏感和大场面掌控上，确实很见功力。以及，温子仁还融入了很多他自己的趣味，也算很有趣的细节了。整体可看性还不错，就是略长了，海底的光怪陆离，看久了也会有些视觉疲劳。', 5, '2019-07-13 11:38:06');
INSERT INTO `comment` VALUES (24, 3, '渔夫和灯塔守护多数是鳏夫，私下里经常养一些人鱼交欢。海洋远比陆地深远得多，人们赞美阳光下的海洋，却不知深夜降临海面上会冒出可怕的妖怪，海底也会藏着嘲笑人类的高级文明。所以！温子仁同样是一个借大热系列ip来讲自己故事的导演！', 3, '2019-07-13 11:38:35');
INSERT INTO `comment` VALUES (25, 3, '故事老套了一点 但是昨晚我的主要任务是努力让自己不要在影院里发大水…Jason太尼玛适合这个角色了，就算他能轻而易举的把我操坏我也心甘情愿地承受这份痛苦', 9, '2019-07-13 11:39:10');
INSERT INTO `comment` VALUES (26, 4, '飞机里的那一段是纪念，也是传承。钢铁侠说过，我们做的一切其实并不重要，重要的是我们选择给后代留下什么。而蜘蛛侠是托尼留给我们最好的遗产。', 10, '2019-07-13 11:39:30');
INSERT INTO `comment` VALUES (27, 4, '多年以后，面对敌人，蜘蛛侠彼得·帕克将会回想起，托尼·斯塔克带他见识超级英雄们的那个遥远的下午。 两个彩蛋比正片有意思', 7, '2019-07-13 11:39:41');
INSERT INTO `comment` VALUES (28, 4, '轻轻松松、啪啪砰砰，这样的超级英雄电影不挺好？温子仁真DC良心大管家——从头到尾堆特效，经费才烧1.6亿！欣赏不来海王徐锦江，51岁的妮可真的美炸了~~~~~', 6, '2019-07-13 11:39:57');
INSERT INTO `comment` VALUES (29, 4, '天空属于卢卡斯 陆地属于杰克逊 海洋属于温子仁！！！', 2, '2019-07-13 11:40:13');
INSERT INTO `comment` VALUES (30, 4, '特效和场景都非常不错，但是剧情和主角都非常不真实，唯一的真实人类就是那个收到新衣服以后改颜色镶铆钉的生命力很旺盛的青蛙反派。', 8, '2019-07-13 11:40:20');
INSERT INTO `comment` VALUES (32, 5, '3.5；失落的亚特兰蒂斯之国，古远传说提供与一般超英片迥异的丰富背景，DC另辟蹊径，开启美妙神秘的水下世界，星站兵密集，温子仁不负众望且适时塞私货，海沟一战jump scare其乐无穷。视效惊人，音效震人，抛却鸡汤亲情，大场面调度甚是过瘾。妮可基德曼真·女神，形象太契合。', 2, '2019-07-13 11:41:14');
INSERT INTO `comment` VALUES (33, 5, '我宣布！2018就是骨科文艺复兴之年！！！', 9, '2019-07-13 11:41:29');
INSERT INTO `comment` VALUES (38, 2, '毒液好丑啊', 1, '2019-07-21 06:40:43');
INSERT INTO `comment` VALUES (39, 4, '哇，这个毒液真的丑，但是女主真的好看！', 1, '2019-07-21 08:59:44');
INSERT INTO `comment` VALUES (40, 6, '以为是R级片，结果是儿童片。汤老湿毫无邪气只有痞气，把一个反派英雄演得正气凛然到闷，而且毒液跟《寄生兽》一样竟然养着养着就变宠物了77', 1, '2019-07-21 09:04:27');
INSERT INTO `comment` VALUES (41, 5, '无名之辈@@', 3, '2019-07-21 09:05:03');
INSERT INTO `comment` VALUES (42, 5, '你好之华', 5, '2019-07-21 09:05:46');
INSERT INTO `comment` VALUES (43, 6, '你的眼睛像火蜥蜴是我笨拙的情话，疯子离开懦夫是她最凶的咒骂，交换亲人让我的愧疚在博格特前显形，歃血为盟使我的爱在厄里斯镜里再现。点金石可以长生，纳吉尼终会成兽，爱心咒语不能保证天长地久，万咒皆终无法阻止核爆之灾。听说魔法世界也有很多爱恨与无奈，麻瓜世界里今年我的入学信还是被寄丢。', 2, '2019-07-21 09:06:34');
INSERT INTO `comment` VALUES (44, 6, '活人办了葬礼，死人偏剩一口气。手机那头她是暗夜里绽放的花，天台边缘她是绝路尽头的桥。两个抢手机模型的憨皮，却无比清醒地看到对方的痴，何惧陷阱，哪管嫌疑。有的人是还没剥开的蛋壳，有的人是胸口夹带的铁板，有的人是虚张声势的水枪，有的人是无法愈合的伤口。几分痴憨皆是勇，几句咒骂都是爱。', 3, '2019-07-21 09:07:47');
INSERT INTO `comment` VALUES (45, 3, '毒液好恶心，快看吐了。', 1, '2019-07-21 09:08:33');
INSERT INTO `comment` VALUES (46, 6, '在岩井俊二的作品里算不上好，但也不差。里面的“时空信息传递”、“替身与错位”，看似是《情书》的反面，实则挖掘的是家庭代际的空间，引出稍显过满的群戏——每个角色都有互文关系。演员方面重点夸下金马提名的张子枫，没想到她竟是戏眼，两次落泪都是因为她。', 5, '2019-07-21 09:08:54');
INSERT INTO `comment` VALUES (47, 3, '允儿来了zz', 1, '2019-07-21 09:09:21');
INSERT INTO `comment` VALUES (48, 6, '顶顶顶', 4, '2019-07-21 09:09:23');
INSERT INTO `comment` VALUES (49, 6, '别想着拍给年轻人看，拍给人看行不行。', 15, '2019-07-21 09:10:12');
INSERT INTO `comment` VALUES (50, 6, '古天乐又缺钱建学校了', 16, '2019-07-21 09:10:38');
INSERT INTO `comment` VALUES (51, 6, '以为玩三就完结甚至不敢期待怕失望，然而完全是惊喜。新元素加入很出彩，Woody找到归属，我的玩具系列完美结局。', 17, '2019-07-21 09:11:04');
INSERT INTO `comment` VALUES (52, 6, '有点泰国惊悚片的味道了，说实话我好几次被吓的冷汗都出来了；虽然有一些场景还是感觉逻辑不通，但至少画面和节奏不渣。本来我都不知道这部电影，但是我对象说要看，那就看了这部，现在的问题是，他不在家的时候我怎么办？', 18, '2019-07-21 09:11:39');
INSERT INTO `comment` VALUES (53, 6, '一个悲伤的故事：太阳都要毁灭，地球都要流浪了，我国的校服还是这么丑......', 20, '2019-07-21 09:12:06');
INSERT INTO `comment` VALUES (54, 6, '不拍妓女三部曲的陈果就不是陈果了。电影拍得跟开玩笑一样。就像故事的走向，演员的演法，都带着些玩世不恭。而这不是诙谐是轻佻。观众并不想看你们在大银幕开玩笑。', 21, '2019-07-21 09:12:31');
INSERT INTO `comment` VALUES (55, 3, '我的青春也全都是你呀', 26, '2019-07-21 09:19:26');
INSERT INTO `comment` VALUES (56, 1, '观后影片：111', 1, '2019-07-22 11:15:03');
INSERT INTO `comment` VALUES (57, 1, '神奇个锤子', 2, '2019-07-22 11:46:01');
-- ----------------------------
-- Table structure for hall
-- ----------------------------
DROP TABLE IF EXISTS `hall`;
CREATE TABLE `hall` (
`hall_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT '放映厅编号',
`hall_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '放映厅名称',
`hall_capacity` int(10) NOT NULL DEFAULT 144 COMMENT '放映厅容量 默认为144 12 x 12 ',
`cinema_id` bigint(10) NOT NULL COMMENT '所属影院编号',
PRIMARY KEY (`hall_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 52 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of hall
-- ----------------------------
INSERT INTO `hall` VALUES (1, '1号厅', 144, 1);
INSERT INTO `hall` VALUES (2, '1号厅', 144, 2);
INSERT INTO `hall` VALUES (3, '1号厅', 144, 3);
INSERT INTO `hall` VALUES (4, '1号厅', 144, 4);
INSERT INTO `hall` VALUES (5, '1号厅', 144, 5);
INSERT INTO `hall` VALUES (6, '1号厅', 144, 6);
INSERT INTO `hall` VALUES (7, '2号厅', 144, 1);
INSERT INTO `hall` VALUES (8, '2号厅', 144, 2);
INSERT INTO `hall` VALUES (9, '2号厅', 144, 3);
INSERT INTO `hall` VALUES (10, '2号厅', 144, 4);
INSERT INTO `hall` VALUES (11, '2号厅', 144, 5);
INSERT INTO `hall` VALUES (12, '2号厅', 144, 6);
INSERT INTO `hall` VALUES (13, '3号厅', 144, 1);
INSERT INTO `hall` VALUES (14, '1号厅', 144, 7);
INSERT INTO `hall` VALUES (15, '1号厅', 144, 8);
INSERT INTO `hall` VALUES (16, '1号厅', 144, 9);
INSERT INTO `hall` VALUES (17, '1号厅', 144, 10);
INSERT INTO `hall` VALUES (18, '1号厅', 144, 11);
INSERT INTO `hall` VALUES (19, '1号厅', 144, 12);
INSERT INTO `hall` VALUES (20, '1号厅', 144, 13);
INSERT INTO `hall` VALUES (21, '1号厅', 144, 14);
INSERT INTO `hall` VALUES (22, '1号厅', 144, 15);
INSERT INTO `hall` VALUES (23, '1号厅', 144, 16);
INSERT INTO `hall` VALUES (24, '1号厅', 144, 17);
INSERT INTO `hall` VALUES (25, '1号厅', 144, 18);
INSERT INTO `hall` VALUES (26, '2号厅', 144, 7);
INSERT INTO `hall` VALUES (27, '2号厅', 144, 8);
INSERT INTO `hall` VALUES (28, '2号厅', 144, 9);
INSERT INTO `hall` VALUES (29, '2号厅', 144, 10);
INSERT INTO `hall` VALUES (30, '2号厅', 144, 11);
INSERT INTO `hall` VALUES (31, '2号厅', 144, 12);
INSERT INTO `hall` VALUES (32, '2号厅', 144, 13);
INSERT INTO `hall` VALUES (33, '2号厅', 144, 14);
INSERT INTO `hall` VALUES (34, '2号厅', 144, 15);
INSERT INTO `hall` VALUES (35, '2号厅', 144, 16);
INSERT INTO `hall` VALUES (36, '2号厅', 144, 17);
INSERT INTO `hall` VALUES (37, '2号厅', 144, 18);
INSERT INTO `hall` VALUES (38, '3号厅', 144, 3);
INSERT INTO `hall` VALUES (39, '3号厅', 144, 5);
INSERT INTO `hall` VALUES (40, '3号厅', 144, 7);
INSERT INTO `hall` VALUES (41, '3号厅', 144, 10);
INSERT INTO `hall` VALUES (42, '3号厅', 144, 11);
INSERT INTO `hall` VALUES (43, '3号厅', 144, 15);
INSERT INTO `hall` VALUES (44, '3号厅', 144, 18);
INSERT INTO `hall` VALUES (45, 'IMAX厅', 144, 1);
INSERT INTO `hall` VALUES (46, 'IMAX厅', 144, 3);
INSERT INTO `hall` VALUES (47, 'IMAX厅', 144, 8);
INSERT INTO `hall` VALUES (48, 'IMAX厅', 144, 12);
INSERT INTO `hall` VALUES (49, 'IMAX厅', 144, 14);
INSERT INTO `hall` VALUES (50, 'IMAX厅', 144, 16);
INSERT INTO `hall` VALUES (51, 'IMAX厅', 144, 17);
-- ----------------------------
-- Table structure for movie
-- ----------------------------
DROP TABLE IF EXISTS `movie`;
CREATE TABLE `movie` (
`movie_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT '电影编号',
`movie_cn_name` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '电影名称（中文）',
`movie_fg_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '电影名称（外语）',
`movie_actor` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影演职人员',
`movie_director` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影导演',
`movie_detail` varchar(350) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影详情',
`movie_duration` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影时长',
`movie_type` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影类型',
`movie_score` float(10, 1) NULL DEFAULT 0.0 COMMENT '电影评分 默认为0',
`movie_boxOffice` float(10, 4) NULL DEFAULT 0.0000 COMMENT '电影票房 默认为0',
`movie_commentCount` bigint(10) NULL DEFAULT 0 COMMENT '电影参评人数 默认为0',
`movie_releaseDate` date NOT NULL COMMENT '电影上映时间',
`movie_country` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影制片地区',
`movie_picture` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影海报',
`movie_state` int(3) NOT NULL DEFAULT 1 COMMENT '电影状态 默认为1 1：在线 0：下架',
PRIMARY KEY (`movie_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 29 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of movie
-- ----------------------------
INSERT INTO `movie` VALUES (1, '毒液：致命守护者', 'Venom', '汤姆·哈迪:埃迪·布洛克/毒液,米歇尔·威廉姆斯:安妮·韦英', '鲁本·弗雷斯彻', '身为记者的埃迪·布洛克（汤姆·哈迪饰）在调查生命基金会老板卡尔顿·德雷克（里兹·阿迈德饰）的过程中，事业遭受重创，与未婚妻安妮·韦英（米歇尔·威廉姆斯饰）的关系岌岌可危，并意外被外星共生体控制，他历经挣扎对抗，最终成为拥有强大超能力，无人可挡的“毒液“', '107分钟', '动作，科幻', 7.2, 1.0209, 7, '2019-06-24', '美国', '../upload/movies/c91fef2f9e2b4d5295cd12e9abf507d9.jpg', 1);
INSERT INTO `movie` VALUES (2, '神奇动物：格林德沃之罪', 'Fantastic Beasts: The Crimes of Grindelwald', '埃迪·雷德梅恩:纽特·斯卡曼德,凯瑟琳·沃特斯顿:蒂娜‧戈德斯坦,约翰尼·德普:盖勒·格林德沃', '大卫·叶茨', '在《神奇动物在那里》第一部的结尾，纽特·斯卡曼德（埃迪·雷德梅恩 饰）协助美国魔法国会，将强大的黑巫师盖勒特·格林德沃（约翰尼·德普 饰）抓捕归案。但格林德沃不久便兑现狂言成功越狱，并开始纠集信徒，着手实现他们的邪恶目的：让纯血统的巫师成为统治阶层，镇压一切非魔法生物。为挫败格林德沃的阴谋，阿不思·邓布利多（裘德·洛 饰）向昔日的学生纽特·斯卡曼德寻求帮助。纽特欣然允诺，却没有意识到，他将踏上的会是一段充满艰险的未来征途。此时的魔法世界面临空前的分裂乱局，阶层鸿沟日益加深，爱与忠诚备受考验，至亲好友也可能反目成仇……', '134分钟', '奇幻，冒险', 7.7, 1.0339, 5, '2019-06-25', '美国', '../upload/movies/Fantastic Beasts.jpg', 1);
INSERT INTO `movie` VALUES (3, '无名之辈', 'A Cool Fish', '陈建斌:马先勇,任素汐:马嘉旗,潘斌龙:李海根', '饶晓志', '在一座山间小城中，一对低配劫匪、一个落魄的泼皮保安、一个身体残疾却性格彪悍的残毒舌女以及一系列生活在社会不同轨迹上的小人物，在一个貌似平常的日子里，因为一把丢失的老枪和一桩当天发生在城中的乌龙劫案，从而被阴差阳错地拧到一起，发生的一幕幕令人啼笑皆非的荒诞喜剧', '108分钟', '荒诞，喜剧', 9.2, 1.0315, 5, '2019-07-05', '中国大陆', '../upload/movies/A Cool Fish.jpg', 1);
INSERT INTO `movie` VALUES (4, '名侦探柯南：零的执行人', '名探偵コナン ゼロの執行人', '高山南:江户川柯南,山崎和佳奈:毛利兰,林原惠美:灰原哀', '立川让', '5月1日，东京湾边的新建筑“海洋边缘”将举办首脑云集的东京峰会。然而，峰会开办前一周，会场发生超大规模的爆炸事件，并出现了安室透的身影。疑似恐怖袭击的事件引起了警察部门的严肃调查。在警察局大型搜查会议上，公安部门提交证物，却发现疑犯指纹与毛利小五郎（小山力也 配音）指纹吻合。作为律师的妃英理努力收集证据证明丈夫的无辜，却无力阻止毛利小五郎被收监。看到毛利兰（山崎和佳奈 配音）绝望哭泣的样子，柯南（高山南 配音）决定调查事件真相，还毛利小五郎清白。另一方面，少年侦探团的孩子们正紧密关注着无人探测器“天鹅”的回航任务。行踪诡异的安室透、惨遭陷害的毛利小五郎、错综复杂的警察部门、即将着陆的无人探测器；随着“机密任务”进入倒计时，关乎整个东京的可怕计划拉开帷幕…', '111分钟', '悬疑，冒险，动画', 8.5, 1.0256, 4, '2019-07-13', '日本', '../upload/movies/名探偵.jpg', 1);
INSERT INTO `movie` VALUES (5, '你好，之华', 'Last Letter', '周迅:袁之华,秦昊:尹川,杜江:周文涛', '岩井俊二', '有人慌张得见面，有人简单地告别。姐姐袁之南离世的那个清晨，只匆匆留下一封信和一张同学会邀请函。妹妹之华(周迅 饰)代替姐姐参加，却意外遇见年少时的倾慕对象尹川（秦昊 饰）。往日的记忆在苏醒，但再次相见，已物是人非', '114分钟', '爱情', 7.9, 1.0108, 5, '2019-07-20', '中国大陆、日本', '../upload/movies/Last Letter.jpg', 1);
INSERT INTO `movie` VALUES (6, '恐龙王', 'DINO KING', '吕佩玉:钢妈,王衡:斑大师,孙晔:八百度', '施雅雅', '陆地霸主特暴龙“斑大师”和自己的小儿子“小疙瘩”生活在一起。“小疙瘩”自幼失去了母亲，生性懦弱，严厉的“斑大师”虽然心底十分疼爱自己的孩子，但是急于让“小疙瘩”成长为新的陆地霸主，常常忍不住责骂“小疙瘩”，父子俩虽然相依为命，却始终有一些隔阂。 一天“小疙瘩”被几只邪恶的恐爪龙抓走，“斑大师”踏上漫漫的寻子之路，路途中他结识了有高度近视眼的美甲龙“八百度”，两人穿过“巨蝎峡”、走出“长颈龙绿洲”、踏上火山峡谷，经历了重重难关。而身处险境的“小疙瘩”也结识了一些新的朋友，并且开始和邪恶的恐爪龙斗智斗勇。最终父子两人终于相见，但是却不得不一起面对一个更加凶恶的史前怪物……', '95分钟', '喜剧，动画，冒险', 8.9, 1.0000, 2, '2018-12-10', '中国大陆', '../upload/movies/DINO KING.jpg', 0);
INSERT INTO `movie` VALUES (7, '冰封侠：时空行者', 'Bing Feng Xia II', '甄子丹:贺英,黄圣依:小美,王宝强:萨獒', '叶伟民', '明朝大将军贺英（甄子丹 饰）利用时空金球终于重返明朝，与锦衣卫兄弟萨獒（王宝强 饰）获悉了倭寇和朝廷奸党之间足以倾覆皇权的密谋，绵延400年的惊天危机一触即发。贺英也在红颜知己小美（黄圣依 饰）的帮助下开始了抗倭锄奸和保护族人的战斗', '87分钟', '剧情，动作', 4.1, 1.0000, 3, '2018-09-02', '中国大陆', '../upload/movies/Bing Feng Xia II.jpg', 0);
INSERT INTO `movie` VALUES (8, '梦境之源', 'Source of Dreams', '陈志朋:徐朗,颜丹晨:李雪,方中信:梁文道', '柳珂', '货车司机李昂由于童年时代内向懦弱，颓废度日，频频做噩梦，严重影响了正常的生活，并因此不得不接受心理医生曹井润的催眠治疗，却在梦境中意外卷入一场凶杀案。睿智破案的警探成为凶手，而真正的幕后黑手仍在逍遥法外……', '90分钟', '悬疑，推理', 5.9, 1.0000, 3, '2018-11-16', '中国大陆', '../upload/movies/Source of Dreams.jpg', 0);
INSERT INTO `movie` VALUES (9, '摘金奇缘', 'Crazy Rich Asians', '吴恬敏:朱瑞秋,亨利·戈尔丁:杨尼克,杨紫琼:杨爱莉', '朱浩伟', '新加坡富二代王子杨尼克（亨利·戈尔丁饰）自豪地带着美丽大方、学识傲人的女友朱瑞秋（吴恬敏饰）回家见亲友。而这个巨富大家族对朱瑞秋的态度，与她的想像相差十万八千里远，朱瑞秋一开始以为只是跟深爱的男人轻松浪漫地度假，不料却面对排山倒海般的压力，她必须坚强应对一群有心机的情敌和反对者，但更难搞的竟然是她的准婆婆杨爱莉（杨紫琼饰），因为埃莉诺认为朱瑞秋这个现代美国女孩永远都高攀不上她们家', '120分钟', '喜剧，爱情', 6.1, 1.0000, 3, '2018-11-30', '美国', '../upload/movies/Crazy Rich Asians.jpg', 0);
INSERT INTO `movie` VALUES (10, '海王', 'Aquaman', '杰森·莫玛:海王/亚瑟·库瑞,艾梅柏·希尔德:海后/湄拉,威廉·达福:努迪斯·维科', '温子仁', '在一场狂风暴雨的海边灯塔看守人汤姆·库瑞（特穆拉·莫里森饰）救了受伤的亚特兰蒂斯女王亚特兰娜（妮可·基德曼饰）之后，他们相爱了，生下了拥有半人类、半亚特兰蒂斯人的血统亚瑟·库瑞（杰森·莫玛饰）。为了救自己的爱人和儿子亚特兰娜选择了离开。\r\n几年之后，亚特兰娜被迫回到海底国家缔结政治婚姻，生下儿子奥姆（帕特里克·威尔森饰）。奥姆长大后当上国王对陆地人类充满憎恨，开始吞并海底中发展中的国家的兵力，一举消灭陆地人。奥姆的未婚妻海底王国泽贝尔公主湄拉（艾梅柏·希尔德饰）打算阻止这场战争，她到陆地找回亚瑟，让他以亚特兰娜女王长子身份回亚特兰蒂斯把王位争回来，而且湄拉要协助亚瑟找回能统治大海的失落的三叉戟', '143分钟', '动作，科幻', 7.6, 1.0000, 3, '2018-12-07', '美国、澳大利亚', '../upload/movies/Aquaman.jpg', 0);
INSERT INTO `movie` VALUES (15, '素人特工', 'The Rookies', '王大陆:赵风,张榕容:淼淼', '袁锦麟', '极限运动达人赵风（王大陆 饰），误打误撞闯入了一场国际犯罪交易，不得不跟随国际特工（米拉·乔沃维奇 饰）一起前往布达佩斯。在这里他与废柴刑警淼淼（张榕容 饰）、民间科学家丁山（许魏洲 饰）与待业医生LV（刘美彤 饰）组成一支素人特工小队。这四个特工小白和高级国际特攻米拉一起，与恐怖分子开启了一场又惊又喜的斗争。', '113分钟', '喜剧,动作,冒险', 7.2, 1.0000, 1, '2019-07-12', '中国大陆', '../upload/movies/素人特工.jpg', 1);
INSERT INTO `movie` VALUES (16, '追龙Ⅱ', 'Chasing the Dragon Ⅱ', '梁家辉:龙志强,古天乐:何天', '王晶', '悍匪龙志强（梁家辉 饰），在香港回归前，趁香港英政府不作为，而屡犯巨案，先后绑架富豪利家及雷家之长子，勒索超过二十亿元，事主怕被报复, 交赎款后都不敢报警。中国公安部极为关注，与香港警方合力，派香港警员何天（古天乐 饰）卧底潜入龙志强犯罪团伙，发现他正策划绑架澳门富豪贺不凡，最终陆港警察合力勇擒龙志强，救出贺不凡', '103分钟', '犯罪,剧情,动作', 7.9, 1.0120, 1, '2019-06-06', '中国大陆、中国香港', '../upload/movies/追龙Ⅱ.jpg', 1);
INSERT INTO `movie` VALUES (17, '玩具总动员4', 'Toy Story 4', '汤姆·汉克斯:胡迪,蒂姆·艾伦:巴斯光年', '乔什·库雷', '当邦妮将所有玩具带上房车家庭旅行时，胡迪（汤姆·汉克斯 配音）与伙伴们将共同踏上全新的冒险之旅，领略房间外面的世界有多广阔，甚至偶遇老朋友牧羊女（安妮·波茨 配音）。在多年的独自闯荡中，牧羊女已经变得热爱冒险，不再只是一个精致的洋娃娃。正当胡迪和牧羊女发现彼此对玩具的使命的意义大相径庭时，他们很快意识到更大的威胁即将到来。', '100分钟', '喜剧,动画,奇幻', 9.1, 1.0000, 1, '2019-06-21', '美国', '../upload/movies/玩具总动员4.jpg', 1);
INSERT INTO `movie` VALUES (18, '碟仙', 'Mortal Ouija', '黄奕:梦瑶,范逸臣:项天', '廉涛', '以网络直播为业的单亲妈妈梦瑶（黄奕 饰）带着上幼儿园的女儿雯雯住进了一栋便宜的学区房，然而，屋里的诡异氛围，与不时散发的奇怪恶臭，令梦瑶感到不安。某夜，雯雯竟然在梦游中，玩了前租客遗留的“碟仙”游戏。传说只要玩过的人，七日内必会被碟仙夺命！紧接着，屋内接连发生令人毛骨悚然的怪事。七日大限将至，眼看爱女危在旦夕，为了解开碟仙诅咒，夺回女儿，绝望的妈妈不惜做出了惊人的举动……', '83分钟', '恐怖,惊悚', 7.9, 1.0056, 1, '2019-06-21', '中国大陆', '../upload/movies/碟仙.jpg', 1);
INSERT INTO `movie` VALUES (19, '扫毒', 'The White Storm', '古天乐:苏建秋,刘青云:马昊天', '陈木胜', '以马昊天（刘青云 饰）为首的毒品调查科，与手下张子伟（张家辉 饰）和卧底苏建秋（古天乐 饰）在执行一次跨国的大型扫毒行动中，被毒犯巨头八面佛（卢海鹏 饰）暗中揭发反埋伏，最终全军覆没。面对生死关头，三位主角为求活存，被迫命运扭转，展开一场残酷的人生战役。', '134分钟', '剧情,犯罪', 8.9, 1.0000, 0, '2018-11-21', '中国大陆、中国香港', '../upload/movies/扫毒.jpg', 0);
INSERT INTO `movie` VALUES (20, '流浪地球', 'The Wandering Earth', '吴京:刘培强,屈楚萧:刘启', '郭帆', '近未来，科学家们发现太阳急速衰老膨胀，短时间内包括地球在内的整个太阳系都将被太阳所吞没。为了自救，人类提出一个名为“流浪地球”的大胆计划，即倾全球之力在地球表面建造上万座发动机和转向发动机，推动地球离开太阳系，用2500年的时间奔往另外一个栖息之地。中国航天员刘培强在儿子刘启四岁那年前往国际空间站，和国际同侪肩负起领航者的重任。转眼刘启长大，他带着妹妹朵朵偷偷跑到地表，偷开外公韩子昂的运输车，结果不仅遭到逮捕，还遭遇了全球发动机停摆的事件。为了修好发动机，阻止地球坠入木星，全球开始展开饱和式营救，连刘启他们的车也被强征加入。在与时间赛跑的过程中，无数的人前仆后继，奋不顾身，只为延续百代子孙生存的希望…… 本片根据刘慈欣的同名小说改编。', '125分钟', '剧情,冒险,科幻', 9.2, 1.0000, 1, '2019-07-05', '中国大陆、中国香港', '../upload/movies/流浪地球.jpg', 1);
INSERT INTO `movie` VALUES (21, '九龙不败', 'The Invincible Dragon', '张晋:九龙', '陈果', '警探九龙（张晋 饰），查案方式奇异狠辣却屡建奇功，是叱咤香港警界的精英干探, 但他处事独断爆裂，又被警队视为“偏执狂人”。九龙奉命调查一桩妙龄女警连环被凶杀 案，用尽手段后不仅毫无线索, 他的警花未婚妻方宁（邓丽欣 饰）竟然也在这场抓捕行动中意外失踪。在爱与痛的边缘挣扎的九龙，突然发现女警连环遇害只是第一步，凶手还有着更加血腥的阴谋，自己和未婚妻竟然也被算计其中。此时澳门再度发生女警被杀案，这次的作案手法更加令人发指，但凶手好像故意留下了线索，是危险陷阱还是复仇曙光？九龙义无反顾出发，在好友王梦奇（刘心悠 饰）及国际拳王冼力山（安德森·席尔瓦 饰）的协助下, 与澳门警司曹志德（郑嘉颖 饰）联手展开调查。魔高一丈，道高几何！血债血偿之前，就算流干最后一滴血，也要誓不罢休。', '100分钟', '剧情,动作,犯罪', 5.7, 1.0000, 1, '2019-07-02', '中国大陆、中国香港', '../upload/movies/九龙不败.jpg', 1);
INSERT INTO `movie` VALUES (22, '阿丽塔：战斗天使', 'Alita: Battle Angel', '罗莎·萨拉查:阿丽塔,克里斯托弗·沃尔兹:戴森·艾德博士', '罗伯特·罗德里格兹', '未来26世纪，科技发展，人类与机械改造人共存，弱肉强食是钢铁城唯一的生存法则。依德（克里斯托夫·沃尔兹 饰）是钢铁城著名的改造人医生，他在垃圾场发现了一个半机械少女残躯，依德医生将其拯救后为她取名阿丽塔（罗莎·萨拉扎尔 饰）。阿丽塔虽然重获生命却失去了记忆，如一个新生儿一样对这个世界充满新鲜感。在依德医生与好友雨果（基恩·约翰逊 饰）的帮助下，她逐步适应着新生活和街头险恶。一次偶然的机会，阿丽塔发现自己竟有着惊人的战斗天赋。 一次次猎杀激发着她的觉醒，阿丽塔逐渐明白自己注定为战斗而生，为正义而战。一场揭开自己身世之谜，并打破宇宙旧秩序的史诗级冒险之旅就这样展开。', '122分钟', '动作,冒险,科幻', 9.0, 1.0000, 0, '2019-07-11', '美国', '../upload/movies/阿丽塔：战斗天使.jpg', 1);
INSERT INTO `movie` VALUES (23, 'X战警：黑凤凰', 'X-Men: Dark Phoenix', '苏菲·特纳:琴·格雷/黑凤凰,詹姆斯·麦卡沃伊:查尔斯·泽维尔/X教授', '西蒙·金伯格', '在一次危及生命的太空营救行动中，琴·葛蕾（苏菲·特纳 饰）被神秘的宇宙力量击中，成为最强大的变种人。此后琴不仅要设法掌控日益增长、极不稳定的力量，更要与自己内心的恶魔抗争，她的失控让整个X战警大家庭分崩离析，也让整个星球陷入毁灭的威胁之中……', '114分钟', '动作,冒险,科幻', 7.8, 1.0000, 0, '2019-06-06', '美国', '../upload/movies/X战警：黑凤凰.jpg', 1);
INSERT INTO `movie` VALUES (24, '疯狂的外星人', 'Crazy Alien', '黄渤:耿浩,沈腾:大飞,马修·莫里森:扎克,汤姆·派福瑞:约翰', '宁浩', '耿浩（黄渤 饰）与一心想发大财的好兄弟大飞（沈腾 饰），经营着各自惨淡的“事业”，然而“天外来客”（徐峥 饰）的意外降临，打破了二人平静又拮据的生活。神秘的西方力量也派出“哼哈二将”在全球搜查外星人行踪。啼笑皆非的跨物种对决，别开生面的“星战”，在中国某海边城市激情上演。', '116分钟', '剧情,喜剧,科幻', 8.5, 1.0000, 0, '2019-07-10', '中国大陆、美国', '../upload/movies/疯狂的外星人.jpg', 1);
INSERT INTO `movie` VALUES (25, '八子', 'ADVANCE WAVE UPON WAVE', '刘端端:满崽,邵兵:大牛', '高希希', '上世纪30年代的赣南地区，在这个被称为中国革命“红色摇篮”的地方，曾经有这样一位母亲，她将八个儿子先后送入红军，奔赴战场前线。但战火无情，兄弟中的六人陆续牺牲，只剩下大哥杨大牛和最小的孩子满崽。满崽找到了大牛的部队，成了哥哥麾下的普通一兵，经过一场场战役的淬炼，新兵满崽迅速成长为一个真正的战士。最后的战斗打响了，为了掩护大部队安全撤离，杨大牛带领弟弟满崽和全体战友浴血肉搏，直至弹尽粮绝…… 英雄的身前，是枪林弹雨的沙场，而在英雄的身后，家乡的村庄依然宁静安详，微风吹过金黄的稻浪簌簌作响，一位年迈的母亲正在村头的小路旁孤独的守望……', '121分钟', '战争,历史,动作', 8.4, 1.0118, 0, '2019-06-30', '中国大陆', '../upload/movies/bazi.jpg', 1);
INSERT INTO `movie` VALUES (26, '我的青春都是你', 'Love The Way You Are', '宋威龙:方予可,宋芸桦:周林林,林妍柔:茹婷,黄俊捷:谢端西,金士杰:畜牧系老师', '周彤', '周林林（宋芸桦 饰）高考发挥超常进入东方大学，与同校理科状元方予可（宋威龙 饰）一同进入了最高学府。郎有情妾无意，方予可其实从幼儿园时期就心系周林林，人生若只如初见，儿时的初遇相见便立下了日久的暗恋情愫！但万人瞩目的帅哥方予可身边有天之骄女茹庭（林妍柔 饰），从小暗恋状元对周林林看不顺眼，周林林则对方予可身边的同为校园风云人物的小西学长（黄俊捷 饰）心存爱慕，修习大学恋爱秘籍，苦练恋爱通关技巧，十八般武艺七十二变法轮番上阵！四人之间情感纠葛，在校园里上演了一幕青春爱情喜剧！', '92分钟', '爱情,青春', 7.3, 1.0000, 1, '2019-06-21', '中国大陆、中国台湾', '../upload/movies/我的青春都是你.jpg', 1);
INSERT INTO `movie` VALUES (27, '银河补习班', 'Looking up', '邓超:马皓文,白宇:成年马飞', '俞白眉', '浩瀚太空，航天员意外失联，生命最大的绝境中，他回忆起自己那个最了不起的爸爸。一对父子跨越漫长的时光，守护爱和亲情，故事充满了欢乐、温暖、泪水与奇观。', '147分钟', '剧情,家庭', 9.1, 1.0200, 0, '2019-07-18', '中国大陆', '../upload/movies/银河补习班.jpg', 1);
INSERT INTO `movie` VALUES (28, '1', '2', '4:4,52:54235', '3', '5', '6', '7', 8.9, 0.0000, 0, '2019-07-02', '9', '../upload/movies/9a9351332a5149c895b57b4564dbe667.jpg', 1);
-- ----------------------------
-- Table structure for orderinfo
-- ----------------------------
DROP TABLE IF EXISTS `orderinfo`;
CREATE TABLE `orderinfo` (
`order_id` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单编号',
`user_id` bigint(10) NOT NULL COMMENT '所属用户编号',
`schedule_id` bigint(10) NOT NULL COMMENT '所属场次编号',
`order_position` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影票座位 （x排x座）',
`order_state` int(10) NOT NULL DEFAULT 1 COMMENT '订单状态 0:退票中 1:已支付 2:退票成功',
`order_price` int(10) NOT NULL COMMENT '订单价格',
`order_time` datetime(0) NOT NULL COMMENT '订单支付时间',
PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of orderinfo
-- ----------------------------
INSERT INTO `orderinfo` VALUES ('2019072100030210', 3, 25, '2排10座', 1, 38, '2019-07-21 07:01:36');
INSERT INTO `orderinfo` VALUES ('2019072100030306', 3, 310, '3排6座', 1, 40, '2019-07-21 14:44:34');
INSERT INTO `orderinfo` VALUES ('2019072100030307', 3, 26, '3排7座', 0, 40, '2019-07-21 07:07:09');
INSERT INTO `orderinfo` VALUES ('2019072100030409', 3, 26, '4排9座', 1, 40, '2019-07-21 07:14:37');
INSERT INTO `orderinfo` VALUES ('2019072100030508', 3, 310, '5排8座', 2, 40, '2019-07-21 14:44:35');
INSERT INTO `orderinfo` VALUES ('2019072100030603', 3, 310, '6排3座', 1, 40, '2019-07-21 14:44:35');
INSERT INTO `orderinfo` VALUES ('2019072100030606', 3, 310, '6排6座', 1, 40, '2019-07-21 14:44:35');
INSERT INTO `orderinfo` VALUES ('2019072100040606', 4, 27, '6排6座', 1, 55, '2019-07-21 08:55:39');
INSERT INTO `orderinfo` VALUES ('2019072100050506', 5, 65, '5排6座', 2, 45, '2019-07-21 08:52:01');
INSERT INTO `orderinfo` VALUES ('2019072100050507', 5, 65, '5排7座', 0, 45, '2019-07-21 08:52:01');
INSERT INTO `orderinfo` VALUES ('2019072100050509', 5, 135, '5排9座', 1, 32, '2019-07-21 08:50:26');
INSERT INTO `orderinfo` VALUES ('2019072100050510', 5, 135, '5排10座', 1, 32, '2019-07-21 08:50:27');
INSERT INTO `orderinfo` VALUES ('2019072100060502', 6, 136, '5排2座', 1, 34, '2019-07-21 08:50:23');
INSERT INTO `orderinfo` VALUES ('2019072100060503', 6, 136, '5排3座', 1, 34, '2019-07-21 08:50:23');
INSERT INTO `orderinfo` VALUES ('2019072100060504', 6, 136, '5排4座', 1, 34, '2019-07-21 08:50:23');
INSERT INTO `orderinfo` VALUES ('2019072100060509', 6, 122, '5排9座', 1, 28, '2019-07-21 08:52:24');
INSERT INTO `orderinfo` VALUES ('2019072100060602', 6, 153, '6排2座', 0, 32, '2019-07-21 08:52:16');
INSERT INTO `orderinfo` VALUES ('2019072100060603', 6, 153, '6排3座', 1, 32, '2019-07-21 08:52:16');
INSERT INTO `orderinfo` VALUES ('2019072100060604', 6, 103, '6排4座', 0, 35, '2019-07-21 08:53:12');
INSERT INTO `orderinfo` VALUES ('2019072100060605', 6, 103, '6排5座', 1, 35, '2019-07-21 08:53:12');
INSERT INTO `orderinfo` VALUES ('2019072100060606', 6, 103, '6排6座', 1, 35, '2019-07-21 08:53:12');
INSERT INTO `orderinfo` VALUES ('2019072100060703', 6, 65, '7排3座', 1, 45, '2019-07-21 08:50:45');
INSERT INTO `orderinfo` VALUES ('2019072100060704', 6, 65, '7排4座', 1, 45, '2019-07-21 08:50:45');
INSERT INTO `orderinfo` VALUES ('2019072100060705', 6, 65, '7排5座', 1, 45, '2019-07-21 08:50:45');
INSERT INTO `orderinfo` VALUES ('2019072100060706', 6, 65, '7排6座', 1, 45, '2019-07-21 08:50:45');
INSERT INTO `orderinfo` VALUES ('2019072100060709', 6, 122, '7排9座', 0, 28, '2019-07-21 08:52:25');
INSERT INTO `orderinfo` VALUES ('2019072100060803', 6, 158, '8排3座', 0, 35, '2019-07-21 08:51:30');
INSERT INTO `orderinfo` VALUES ('2019072100060804', 6, 158, '8排4座', 0, 35, '2019-07-21 08:51:31');
INSERT INTO `orderinfo` VALUES ('2019072200010507', 1, 232, '5排7座', 1, 30, '2019-07-22 11:09:46');
INSERT INTO `orderinfo` VALUES ('2019072200010608', 1, 232, '6排8座', 1, 30, '2019-07-22 11:09:46');
INSERT INTO `orderinfo` VALUES ('2019072200010707', 1, 232, '7排7座', 1, 30, '2019-07-22 11:09:46');
INSERT INTO `orderinfo` VALUES ('2019072200010808', 1, 232, '8排8座', 1, 30, '2019-07-22 11:09:46');
INSERT INTO `orderinfo` VALUES ('2019072200010910', 1, 136, '9排10座', 0, 34, '2019-07-21 17:00:56');
INSERT INTO `orderinfo` VALUES ('2019072200010911', 1, 136, '9排11座', 1, 34, '2019-07-21 17:00:56');
INSERT INTO `orderinfo` VALUES ('2019072200010912', 1, 160, '9排12座', 1, 35, '2019-07-22 11:46:52');
INSERT INTO `orderinfo` VALUES ('2019072200020508', 2, 83, '5排8座', 0, 44, '2019-07-22 11:32:49');
INSERT INTO `orderinfo` VALUES ('2019072200040106', 4, 94, '1排6座', 1, 54, '2019-07-22 01:10:02');
INSERT INTO `orderinfo` VALUES ('2019072200040107', 4, 94, '1排7座', 1, 54, '2019-07-22 01:10:02');
INSERT INTO `orderinfo` VALUES ('2019072200040408', 4, 39, '4排8座', 1, 48, '2019-07-22 03:51:27');
INSERT INTO `orderinfo` VALUES ('2019072200040409', 4, 135, '4排9座', 1, 32, '2019-07-22 01:11:16');
INSERT INTO `orderinfo` VALUES ('2019072200040410', 4, 135, '4排10座', 1, 32, '2019-07-22 01:11:16');
INSERT INTO `orderinfo` VALUES ('2019072200040508', 4, 135, '5排8座', 1, 32, '2019-07-22 01:11:16');
INSERT INTO `orderinfo` VALUES ('2019072200040511', 4, 135, '5排11座', 1, 32, '2019-07-22 01:11:16');
INSERT INTO `orderinfo` VALUES ('2019072200040609', 4, 135, '6排9座', 1, 32, '2019-07-22 01:11:45');
INSERT INTO `orderinfo` VALUES ('2019072200040610', 4, 135, '6排10座', 1, 32, '2019-07-22 01:11:45');
INSERT INTO `orderinfo` VALUES ('2019072400010310', 1, 27, '3排10座', 1, 55, '2019-07-24 02:30:42');
INSERT INTO `orderinfo` VALUES ('2019072400010311', 1, 27, '3排11座', 1, 55, '2019-07-24 02:30:43');
-- ----------------------------
-- Table structure for schedule
-- ----------------------------
DROP TABLE IF EXISTS `schedule`;
CREATE TABLE `schedule` (
`schedule_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT '场次编号',
`hall_id` bigint(10) NOT NULL COMMENT '所属放映厅编号',
`movie_id` bigint(10) NOT NULL COMMENT '所属电影编号',
`schedule_startTime` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '电影放映时间',
`schedule_price` int(10) NOT NULL COMMENT '场次价格',
`schedule_remain` int(10) NOT NULL COMMENT '剩余座位数 默认=hall_capacity',
`schedule_state` int(10) NOT NULL DEFAULT 1 COMMENT '场次状态 默认1 1：上映中 0：下架',
PRIMARY KEY (`schedule_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 315 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of schedule
-- ----------------------------
INSERT INTO `schedule` VALUES (25, 1, 25, '2019-07-21 17:30', 38, 144, 1);
INSERT INTO `schedule` VALUES (26, 7, 25, '2019-07-22 20:00', 40, 143, 1);
INSERT INTO `schedule` VALUES (27, 7, 1, '2019-07-21 19:10', 55, 141, 0);
INSERT INTO `schedule` VALUES (28, 8, 25, '2019-07-23 17:00', 48, 144, 1);
INSERT INTO `schedule` VALUES (29, 1, 20, '2019-07-21 00:00', 38, 144, 1);
INSERT INTO `schedule` VALUES (30, 13, 1, '2019-07-22 19:20', 55, 144, 1);
INSERT INTO `schedule` VALUES (31, 7, 20, '2019-07-21 00:00', 38, 144, 1);
INSERT INTO `schedule` VALUES (32, 13, 20, '2019-07-21 00:00', 38, 144, 1);
INSERT INTO `schedule` VALUES (33, 1, 1, '2019-07-23 20:00', 55, 144, 1);
INSERT INTO `schedule` VALUES (34, 45, 20, '2019-07-22 20:30', 58, 144, 1);
INSERT INTO `schedule` VALUES (35, 8, 25, '2019-07-24 00:00', 39, 144, 1);
INSERT INTO `schedule` VALUES (36, 7, 1, '2019-07-24 20:10', 55, 144, 1);
INSERT INTO `schedule` VALUES (37, 7, 20, '2019-07-22 15:30', 38, 144, 1);
INSERT INTO `schedule` VALUES (38, 8, 20, '2019-07-23 14:20', 39, 144, 1);
INSERT INTO `schedule` VALUES (39, 2, 1, '2019-07-21 10:10', 48, 143, 1);
INSERT INTO `schedule` VALUES (40, 2, 1, '2019-07-22 10:10', 45, 144, 1);
INSERT INTO `schedule` VALUES (41, 8, 20, '2019-07-23 21:45', 39, 144, 1);
INSERT INTO `schedule` VALUES (42, 11, 25, '2019-07-23 12:30', 28, 144, 1);
INSERT INTO `schedule` VALUES (43, 8, 20, '2019-07-23 10:40', 39, 144, 1);
INSERT INTO `schedule` VALUES (44, 29, 25, '2019-07-25 00:00', 40, 144, 1);
INSERT INTO `schedule` VALUES (45, 8, 1, '2019-07-23 10:20', 45, 144, 1);
INSERT INTO `schedule` VALUES (46, 2, 20, '2019-07-22 19:30', 39, 144, 1);
INSERT INTO `schedule` VALUES (47, 8, 1, '2019-07-24 10:20', 45, 144, 1);
INSERT INTO `schedule` VALUES (48, 37, 25, '2019-07-23 20:00', 38, 144, 0);
INSERT INTO `schedule` VALUES (49, 45, 20, '2019-07-23 20:20', 58, 144, 1);
INSERT INTO `schedule` VALUES (50, 7, 20, '2019-07-23 16:20', 38, 144, 1);
INSERT INTO `schedule` VALUES (51, 46, 20, '2019-07-23 15:15', 68, 144, 1);
INSERT INTO `schedule` VALUES (52, 3, 1, '2019-07-23 10:00', 45, 144, 1);
INSERT INTO `schedule` VALUES (53, 14, 20, '2019-07-24 13:00', 39, 144, 1);
INSERT INTO `schedule` VALUES (54, 46, 1, '2019-07-23 19:20', 67, 144, 1);
INSERT INTO `schedule` VALUES (55, 29, 20, '2019-07-24 17:10', 38, 144, 1);
INSERT INTO `schedule` VALUES (56, 9, 1, '2019-07-24 09:40', 45, 144, 1);
INSERT INTO `schedule` VALUES (57, 46, 1, '2019-07-24 19:30', 66, 144, 1);
INSERT INTO `schedule` VALUES (58, 32, 20, '2019-07-23 09:30', 36, 144, 1);
INSERT INTO `schedule` VALUES (59, 24, 3, '2019-07-25 13:35', 45, 144, 1);
INSERT INTO `schedule` VALUES (60, 49, 25, '2019-07-24 10:00', 50, 144, 1);
INSERT INTO `schedule` VALUES (61, 37, 20, '2019-07-23 22:00', 38, 144, 1);
INSERT INTO `schedule` VALUES (62, 5, 1, '2019-07-23 10:15', 43, 144, 1);
INSERT INTO `schedule` VALUES (63, 51, 3, '2019-07-23 17:05', 35, 144, 1);
INSERT INTO `schedule` VALUES (64, 36, 25, '2019-07-23 19:30', 38, 144, 1);
INSERT INTO `schedule` VALUES (65, 35, 3, '2019-07-24 19:05', 45, 138, 1);
INSERT INTO `schedule` VALUES (66, 29, 20, '2019-07-24 07:15', 38, 144, 1);
INSERT INTO `schedule` VALUES (67, 4, 26, '2019-07-23 20:00', 28, 144, 1);
INSERT INTO `schedule` VALUES (68, 16, 3, '2019-07-23 18:05', 40, 144, 1);
INSERT INTO `schedule` VALUES (69, 10, 20, '2019-07-24 13:35', 38, 144, 1);
INSERT INTO `schedule` VALUES (70, 33, 26, '2019-07-24 21:00', 22, 144, 1);
INSERT INTO `schedule` VALUES (71, 4, 1, '2019-07-23 09:45', 43, 144, 1);
INSERT INTO `schedule` VALUES (72, 10, 1, '2019-07-23 19:20', 43, 144, 1);
INSERT INTO `schedule` VALUES (73, 24, 3, '2019-07-25 21:00', 45, 144, 1);
INSERT INTO `schedule` VALUES (74, 11, 21, '2019-07-23 14:15', 36, 144, 1);
INSERT INTO `schedule` VALUES (75, 23, 26, '2019-07-24 13:00', 25, 144, 1);
INSERT INTO `schedule` VALUES (76, 4, 1, '2019-07-24 09:50', 43, 144, 1);
INSERT INTO `schedule` VALUES (77, 31, 3, '2019-07-26 12:45', 35, 144, 1);
INSERT INTO `schedule` VALUES (78, 37, 26, '2019-07-24 19:05', 38, 144, 1);
INSERT INTO `schedule` VALUES (79, 11, 21, '2019-07-23 15:25', 36, 144, 1);
INSERT INTO `schedule` VALUES (80, 10, 1, '2019-07-24 20:00', 43, 144, 1);
INSERT INTO `schedule` VALUES (81, 10, 26, '2019-07-23 22:05', 28, 144, 1);
INSERT INTO `schedule` VALUES (82, 39, 21, '2019-07-23 20:05', 36, 144, 1);
INSERT INTO `schedule` VALUES (83, 11, 1, '2019-07-23 21:10', 44, 143, 1);
INSERT INTO `schedule` VALUES (84, 5, 21, '2019-07-24 10:20', 36, 144, 1);
INSERT INTO `schedule` VALUES (85, 24, 26, '2019-07-24 17:30', 25, 144, 1);
INSERT INTO `schedule` VALUES (86, 31, 26, '2019-07-22 19:00', 28, 144, 1);
INSERT INTO `schedule` VALUES (87, 5, 1, '2019-07-24 09:30', 43, 144, 1);
INSERT INTO `schedule` VALUES (88, 11, 21, '2019-07-24 22:15', 36, 144, 1);
INSERT INTO `schedule` VALUES (89, 17, 26, '2019-07-22 00:00', 29, 144, 1);
INSERT INTO `schedule` VALUES (90, 35, 3, '2019-07-24 18:40', 34, 144, 1);
INSERT INTO `schedule` VALUES (91, 39, 1, '2019-07-24 20:25', 44, 144, 1);
INSERT INTO `schedule` VALUES (92, 12, 21, '2019-07-23 14:10', 29, 144, 1);
INSERT INTO `schedule` VALUES (93, 12, 26, '2019-07-23 22:00', 29, 144, 1);
INSERT INTO `schedule` VALUES (94, 24, 5, '2019-07-21 19:55', 54, 142, 1);
INSERT INTO `schedule` VALUES (95, 12, 21, '2019-07-23 16:05', 29, 144, 1);
INSERT INTO `schedule` VALUES (96, 6, 1, '2019-07-23 10:20', 46, 144, 1);
INSERT INTO `schedule` VALUES (97, 8, 26, '2019-07-23 10:00', 25, 144, 1);
INSERT INTO `schedule` VALUES (98, 47, 24, '2019-07-28 14:45', 33, 144, 1);
INSERT INTO `schedule` VALUES (99, 12, 21, '2019-07-24 10:00', 29, 144, 1);
INSERT INTO `schedule` VALUES (100, 6, 1, '2019-07-23 21:10', 46, 144, 1);
INSERT INTO `schedule` VALUES (101, 29, 26, '2019-07-23 20:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (102, 12, 1, '2019-07-24 10:10', 46, 144, 1);
INSERT INTO `schedule` VALUES (103, 30, 21, '2019-07-23 13:10', 35, 141, 1);
INSERT INTO `schedule` VALUES (104, 12, 1, '2019-07-24 20:40', 46, 144, 1);
INSERT INTO `schedule` VALUES (105, 30, 21, '2019-07-23 21:05', 35, 144, 1);
INSERT INTO `schedule` VALUES (106, 25, 26, '2019-07-24 23:00', 39, 144, 1);
INSERT INTO `schedule` VALUES (107, 28, 21, '2019-07-24 16:05', 38, 144, 1);
INSERT INTO `schedule` VALUES (108, 14, 1, '2019-07-23 19:20', 44, 144, 1);
INSERT INTO `schedule` VALUES (109, 1, 15, '2019-07-23 16:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (110, 26, 1, '2019-07-24 10:20', 44, 144, 1);
INSERT INTO `schedule` VALUES (111, 51, 22, '2019-07-21 00:00', 59, 144, 1);
INSERT INTO `schedule` VALUES (112, 40, 1, '2019-07-24 22:00', 44, 144, 1);
INSERT INTO `schedule` VALUES (113, 4, 18, '2019-07-25 08:05', 65, 144, 1);
INSERT INTO `schedule` VALUES (114, 36, 22, '2019-07-21 00:00', 58, 144, 1);
INSERT INTO `schedule` VALUES (115, 34, 22, '2019-07-23 13:15', 49, 144, 1);
INSERT INTO `schedule` VALUES (116, 31, 22, '2019-07-23 13:20', 49, 144, 1);
INSERT INTO `schedule` VALUES (117, 16, 17, '2019-07-24 09:10', 35, 144, 1);
INSERT INTO `schedule` VALUES (118, 15, 1, '2019-07-23 20:30', 43, 144, 1);
INSERT INTO `schedule` VALUES (119, 27, 1, '2019-07-24 09:50', 43, 144, 1);
INSERT INTO `schedule` VALUES (120, 47, 18, '2019-07-25 16:30', 54, 144, 1);
INSERT INTO `schedule` VALUES (121, 47, 1, '2019-07-24 20:40', 56, 144, 1);
INSERT INTO `schedule` VALUES (122, 43, 18, '2019-07-24 04:25', 28, 142, 1);
INSERT INTO `schedule` VALUES (123, 1, 15, '2019-07-21 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (124, 16, 1, '2019-07-23 21:20', 41, 144, 1);
INSERT INTO `schedule` VALUES (125, 34, 18, '2019-07-21 17:15', 34, 144, 1);
INSERT INTO `schedule` VALUES (126, 7, 15, '2019-07-22 16:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (127, 28, 1, '2019-07-24 20:30', 41, 144, 1);
INSERT INTO `schedule` VALUES (128, 17, 1, '2019-07-23 14:15', 42, 144, 1);
INSERT INTO `schedule` VALUES (129, 1, 15, '2019-07-21 20:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (130, 29, 1, '2019-07-24 09:00', 42, 144, 1);
INSERT INTO `schedule` VALUES (131, 7, 15, '2019-07-22 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (132, 36, 22, '2019-07-24 16:20', 48, 144, 1);
INSERT INTO `schedule` VALUES (133, 3, 16, '2019-07-24 10:10', 45, 144, 1);
INSERT INTO `schedule` VALUES (134, 13, 15, '2019-07-23 10:30', 30, 144, 1);
INSERT INTO `schedule` VALUES (135, 25, 4, '2019-07-21 05:25', 32, 136, 1);
INSERT INTO `schedule` VALUES (136, 1, 2, '2019-07-23 10:05', 34, 139, 1);
INSERT INTO `schedule` VALUES (137, 13, 15, '2019-07-23 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (138, 7, 2, '2019-07-23 22:15', 34, 144, 1);
INSERT INTO `schedule` VALUES (139, 48, 22, '2019-07-24 15:25', 58, 144, 1);
INSERT INTO `schedule` VALUES (140, 49, 23, '2019-07-21 15:15', 42, 144, 1);
INSERT INTO `schedule` VALUES (141, 13, 15, '2019-07-24 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (142, 30, 22, '2019-07-23 16:15', 48, 144, 1);
INSERT INTO `schedule` VALUES (143, 7, 15, '2019-07-24 18:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (144, 13, 2, '2019-07-24 17:10', 34, 144, 1);
INSERT INTO `schedule` VALUES (145, 7, 15, '2019-07-24 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (146, 25, 2, '2019-07-23 19:30', 33, 144, 1);
INSERT INTO `schedule` VALUES (147, 40, 23, '2019-07-23 10:30', 39, 144, 1);
INSERT INTO `schedule` VALUES (148, 37, 2, '2019-07-24 10:05', 34, 144, 1);
INSERT INTO `schedule` VALUES (149, 26, 23, '2019-07-23 20:15', 39, 144, 1);
INSERT INTO `schedule` VALUES (150, 44, 2, '2019-07-24 19:10', 34, 144, 1);
INSERT INTO `schedule` VALUES (151, 24, 2, '2019-07-22 00:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (152, 32, 23, '2019-07-23 13:30', 40, 144, 1);
INSERT INTO `schedule` VALUES (153, 36, 2, '2019-07-23 00:00', 32, 142, 1);
INSERT INTO `schedule` VALUES (154, 51, 2, '2019-07-24 00:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (155, 10, 23, '2019-07-23 13:20', 39, 144, 1);
INSERT INTO `schedule` VALUES (156, 2, 15, '2019-07-21 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (157, 33, 23, '2019-07-23 19:15', 38, 144, 1);
INSERT INTO `schedule` VALUES (158, 23, 2, '2019-07-23 09:00', 35, 142, 1);
INSERT INTO `schedule` VALUES (159, 2, 15, '2019-07-21 16:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (160, 35, 2, '2019-07-24 21:00', 35, 143, 1);
INSERT INTO `schedule` VALUES (161, 8, 15, '2019-07-21 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (162, 50, 2, '2019-07-25 20:05', 45, 144, 1);
INSERT INTO `schedule` VALUES (163, 8, 15, '2019-07-21 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (164, 22, 2, '2019-07-22 00:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (165, 27, 23, '2019-07-23 16:15', 38, 144, 1);
INSERT INTO `schedule` VALUES (166, 2, 15, '2019-07-21 20:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (167, 34, 2, '2019-07-23 00:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (168, 43, 2, '2019-07-24 00:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (169, 47, 24, '2019-07-23 16:10', 48, 144, 1);
INSERT INTO `schedule` VALUES (170, 2, 15, '2019-07-23 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (171, 28, 24, '2019-07-23 15:05', 38, 144, 1);
INSERT INTO `schedule` VALUES (172, 8, 15, '2019-07-23 10:30', 30, 144, 1);
INSERT INTO `schedule` VALUES (173, 29, 24, '2019-07-21 15:20', 38, 144, 1);
INSERT INTO `schedule` VALUES (174, 20, 3, '2019-07-23 09:00', 27, 144, 1);
INSERT INTO `schedule` VALUES (175, 8, 15, '2019-07-24 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (176, 32, 3, '2019-07-24 12:15', 27, 144, 1);
INSERT INTO `schedule` VALUES (177, 34, 24, '2019-07-24 10:20', 38, 144, 1);
INSERT INTO `schedule` VALUES (178, 8, 15, '2019-07-24 13:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (179, 4, 3, '2019-07-23 15:00', 27, 144, 1);
INSERT INTO `schedule` VALUES (180, 8, 15, '2019-07-24 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (181, 10, 3, '2019-07-24 17:00', 27, 144, 1);
INSERT INTO `schedule` VALUES (182, 3, 15, '2019-07-22 09:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (183, 42, 24, '2019-07-24 13:35', 38, 144, 1);
INSERT INTO `schedule` VALUES (184, 25, 3, '2019-07-22 08:00', 26, 144, 1);
INSERT INTO `schedule` VALUES (185, 3, 15, '2019-07-22 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (186, 9, 15, '2019-07-22 16:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (187, 38, 15, '2019-07-24 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (188, 37, 3, '2019-07-24 14:05', 26, 144, 1);
INSERT INTO `schedule` VALUES (189, 35, 24, '2019-07-24 16:15', 38, 144, 1);
INSERT INTO `schedule` VALUES (190, 38, 15, '2019-07-25 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (191, 44, 3, '2019-07-25 09:00', 26, 144, 1);
INSERT INTO `schedule` VALUES (192, 3, 15, '2019-07-25 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (193, 1, 4, '2019-07-22 23:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (194, 7, 4, '2019-07-23 23:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (195, 35, 24, '2019-07-24 16:20', 38, 144, 1);
INSERT INTO `schedule` VALUES (196, 4, 15, '2019-07-23 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (197, 13, 4, '2019-07-24 23:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (198, 10, 15, '2019-07-23 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (199, 45, 4, '2019-07-25 23:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (200, 10, 15, '2019-07-24 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (201, 20, 4, '2019-07-23 23:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (202, 10, 15, '2019-07-24 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (203, 20, 4, '2019-07-24 23:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (204, 5, 15, '2019-07-23 11:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (205, 4, 4, '2019-07-23 00:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (206, 10, 4, '2019-07-24 00:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (207, 11, 15, '2019-07-23 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (208, 16, 21, '2019-07-23 13:25', 38, 144, 1);
INSERT INTO `schedule` VALUES (209, 39, 15, '2019-07-23 16:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (210, 5, 15, '2019-07-24 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (211, 11, 15, '2019-07-24 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (212, 37, 4, '2019-07-23 15:05', 32, 144, 1);
INSERT INTO `schedule` VALUES (213, 22, 22, '2019-07-23 16:05', 49, 144, 1);
INSERT INTO `schedule` VALUES (214, 44, 4, '2019-07-24 14:10', 32, 144, 1);
INSERT INTO `schedule` VALUES (215, 6, 15, '2019-07-23 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (216, 24, 5, '2019-07-23 04:00', 34, 144, 1);
INSERT INTO `schedule` VALUES (217, 12, 15, '2019-07-23 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (218, 12, 15, '2019-07-24 09:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (219, 42, 22, '2019-07-24 17:00', 48, 144, 1);
INSERT INTO `schedule` VALUES (220, 6, 15, '2019-07-24 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (221, 1, 16, '2019-07-23 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (222, 36, 5, '2019-07-21 14:54', 34, 144, 1);
INSERT INTO `schedule` VALUES (223, 13, 16, '2019-07-23 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (224, 20, 23, '2019-07-24 18:45', 40, 144, 1);
INSERT INTO `schedule` VALUES (225, 15, 5, '2019-07-23 04:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (226, 7, 16, '2019-07-24 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (227, 42, 5, '2019-07-24 04:00', 34, 144, 1);
INSERT INTO `schedule` VALUES (228, 7, 16, '2019-07-24 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (229, 4, 23, '2019-07-24 14:15', 39, 144, 1);
INSERT INTO `schedule` VALUES (230, 27, 5, '2019-07-23 05:05', 33, 144, 1);
INSERT INTO `schedule` VALUES (231, 13, 15, '2019-07-24 18:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (232, 2, 16, '2019-07-23 11:00', 30, 140, 1);
INSERT INTO `schedule` VALUES (233, 47, 23, '2019-07-23 20:15', 58, 144, 1);
INSERT INTO `schedule` VALUES (234, 2, 16, '2019-07-23 16:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (235, 2, 16, '2019-07-24 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (236, 15, 23, '2019-07-24 20:15', 38, 144, 1);
INSERT INTO `schedule` VALUES (237, 8, 16, '2019-07-24 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (238, 11, 5, '2019-07-24 14:57', 32, 144, 1);
INSERT INTO `schedule` VALUES (239, 2, 16, '2019-07-24 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (240, 27, 5, '2019-07-21 14:58', 33, 144, 1);
INSERT INTO `schedule` VALUES (241, 41, 5, '2019-07-24 07:00', 32, 144, 1);
INSERT INTO `schedule` VALUES (242, 16, 24, '2019-07-23 20:05', 38, 144, 1);
INSERT INTO `schedule` VALUES (243, 3, 16, '2019-07-23 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (244, 22, 5, '2019-07-22 05:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (245, 38, 16, '2019-07-23 19:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (246, 34, 5, '2019-07-23 05:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (247, 9, 15, '2019-07-24 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (248, 41, 24, '2019-07-23 12:00', 38, 144, 1);
INSERT INTO `schedule` VALUES (249, 43, 5, '2019-07-24 05:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (250, 9, 16, '2019-07-24 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (251, 17, 24, '2019-07-24 20:15', 38, 144, 1);
INSERT INTO `schedule` VALUES (252, 4, 16, '2019-07-23 11:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (253, 10, 16, '2019-07-24 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (254, 30, 24, '2019-07-23 14:20', 38, 144, 1);
INSERT INTO `schedule` VALUES (255, 5, 16, '2019-07-23 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (256, 22, 24, '2019-07-23 14:20', 38, 144, 1);
INSERT INTO `schedule` VALUES (257, 5, 16, '2019-07-23 19:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (258, 5, 16, '2019-07-24 13:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (259, 39, 16, '2019-07-24 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (260, 6, 16, '2019-07-23 00:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (261, 12, 16, '2019-07-24 16:00', 20, 144, 1);
INSERT INTO `schedule` VALUES (262, 1, 17, '2019-07-23 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (263, 7, 17, '2019-07-23 11:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (264, 13, 17, '2019-07-24 07:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (265, 7, 17, '2019-07-24 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (266, 2, 17, '2019-07-23 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (267, 8, 17, '2019-07-23 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (268, 2, 17, '2019-07-24 09:20', 30, 144, 1);
INSERT INTO `schedule` VALUES (269, 8, 17, '2019-07-24 15:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (270, 3, 17, '2019-07-23 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (271, 9, 17, '2019-07-23 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (272, 38, 17, '2019-07-24 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (273, 4, 17, '2019-07-23 14:00', 20, 144, 1);
INSERT INTO `schedule` VALUES (274, 10, 17, '2019-07-24 14:05', 20, 144, 1);
INSERT INTO `schedule` VALUES (275, 11, 17, '2019-07-23 10:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (276, 11, 17, '2019-07-24 17:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (277, 12, 17, '2019-07-23 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (278, 12, 17, '2019-07-24 11:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (279, 6, 17, '2019-07-23 09:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (280, 39, 17, '2019-07-23 21:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (281, 39, 17, '2019-07-24 00:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (282, 38, 17, '2019-07-24 08:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (283, 1, 18, '2019-07-23 08:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (284, 7, 18, '2019-07-23 12:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (285, 13, 18, '2019-07-24 14:00', 30, 144, 1);
INSERT INTO `schedule` VALUES (286, 1, 18, '2019-07-24 16:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (287, 2, 18, '2019-07-23 17:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (288, 2, 18, '2019-07-23 09:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (289, 2, 18, '2019-07-23 14:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (290, 2, 18, '2019-07-24 10:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (291, 2, 18, '2019-07-24 13:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (292, 3, 18, '2019-07-23 12:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (293, 9, 18, '2019-07-23 20:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (294, 3, 18, '2019-07-23 15:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (295, 9, 18, '2019-07-24 10:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (296, 9, 18, '2019-07-24 11:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (297, 38, 18, '2019-07-24 21:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (298, 10, 18, '2019-07-23 08:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (299, 4, 18, '2019-07-23 11:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (300, 4, 18, '2019-07-24 14:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (301, 10, 18, '2019-07-24 21:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (302, 5, 18, '2019-07-23 08:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (303, 11, 18, '2019-07-24 11:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (304, 39, 18, '2019-07-24 15:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (305, 6, 18, '2019-07-23 10:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (306, 12, 18, '2019-07-24 12:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (307, 12, 18, '2019-07-24 18:00', 33, 144, 1);
INSERT INTO `schedule` VALUES (308, 1, 27, '2019-07-23 00:00', 45, 144, 1);
INSERT INTO `schedule` VALUES (309, 7, 27, '2019-07-24 19:00', 45, 144, 1);
INSERT INTO `schedule` VALUES (310, 8, 27, '2019-07-23 20:00', 40, 140, 1);
INSERT INTO `schedule` VALUES (311, 4, 27, '2019-07-23 16:00', 49, 144, 1);
INSERT INTO `schedule` VALUES (312, 11, 27, '2019-07-24 19:15', 45, 144, 1);
INSERT INTO `schedule` VALUES (313, 8, 27, '2019-07-24 15:00', 35, 144, 1);
INSERT INTO `schedule` VALUES (314, 8, 20, '2019-07-18 04:04', 45, 144, 1);
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`user_id` bigint(10) NOT NULL AUTO_INCREMENT COMMENT '会员编号',
`user_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '会员账号',
`user_pwd` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '会员密码',
`user_email` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '会员邮箱',
`user_role` int(10) NOT NULL DEFAULT 0 COMMENT '会员权限（默认为0）\r\n0：普通会员 1：管理员',
`user_headImg` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '会员头像',
PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 29 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'user', 'user', '33734872621@qq.com', 0, '../upload/head/f6337987771546f9a143fc5206f047f4.jpg');
INSERT INTO `user` VALUES (2, 'admin', 'admin', '3456872621@qq.com', 1, '../upload/head/dc56255b1e4f4ad4b0a76a8eb0fc7f45.jpg');
INSERT INTO `user` VALUES (3, 'wxj', 'wxj', '937872111@126.com', 1, '../upload/head/de9d930c96e240bc9f4f91b914e5dddb.jpg');
INSERT INTO `user` VALUES (4, 'lpf', 'lpf', '23546211543@qq.com', 0, '../upload/head/85c888cf36d649d6aaea58f19cc8c143.jpg');
INSERT INTO `user` VALUES (5, 'wzw', 'wzw', '2154698421@126.com', 0, '../upload/head/bdc1cf2d9b9d4d5ca5d7a34f2ebfc5b3.jpg');
INSERT INTO `user` VALUES (6, 'hzw', 'hzw', 'a487953215@163.com', 0, '../upload/head/demo.jpg');
INSERT INTO `user` VALUES (7, 'lsw', 'lsw', '3215644123@qq.com', 0, '../upload/head/84c69b60d91e4c079e249a6cd09ef91c.jpg');
INSERT INTO `user` VALUES (8, 'bg12356484', '6484', '910050724@qq.com', 0, '../upload/head/demo.jpg');
INSERT INTO `user` VALUES (9, 'ao13546954', '6954', 'hsw236413512@163.com', 0, NULL);
INSERT INTO `user` VALUES (19, 'jd15154478', '4478', '5648132142@163.com', 0, '../upload/head/dc56255b1e4f4ad4b0a76a8eb0fc7f45.jpg');
INSERT INTO `user` VALUES (20, 'sn46845411', '5411', 'gs15648231@126.com', 0, '../upload/head/84c69b60d91e4c079e249a6cd09ef91c.jpg');
INSERT INTO `user` VALUES (21, 'gs12314864', '4864', '2154678122@qq.com', 0, '../upload/head/84c69b60d91e4c079e249a6cd09ef91c.jpg');
INSERT INTO `user` VALUES (22, 'jd12315164', '5164', '211215484@qq.com', 0, '../upload/head/dc56255b1e4f4ad4b0a76a8eb0fc7f45.jpg');
INSERT INTO `user` VALUES (23, 'kl15645641', '5641', 'g123456412@163.com', 0, '../upload/head/dd7cf74e264247ffbe888c4e163fb9ed.jpg');
INSERT INTO `user` VALUES (24, 'kd1231854', '1854', '123484547@qq.com', 0, NULL);
INSERT INTO `user` VALUES (25, 'tw1123484', '3484', '988744641@qq.com', 0, '../upload/head/dc56255b1e4f4ad4b0a76a8eb0fc7f45.jpg');
INSERT INTO `user` VALUES (26, 'if48648411', '8411', 'u365484741@163.com', 0, '../upload/head/dd7cf74e264247ffbe888c4e163fb9ed.jpg');
INSERT INTO `user` VALUES (27, 'od1561487', '1487', '1564562314@qq.com', 0, NULL);
INSERT INTO `user` VALUES (28, 'jd54687233', '7233', '165484754@qq.com', 0, NULL);
SET FOREIGN_KEY_CHECKS = 1;

326
src/main/java/com/controller/CommentController.java
Unescape View File

@ -19,210 +19,132 @@ import com.service.IMovieService;
import com.service.IUserService;
/**
* 评论管理模块，主要负责处理与用户评论相关的各种业务请求，例如查询所有评论、分页查询评论、发表评论、更新评论以及删除评论等操作，
* 通过调用相应服务层接口实现具体业务逻辑，并将结果以 JSON 格式返回给前端页面或其他调用方。
*
* 评论管理模块
* @author Wxj
*/
@Controller
@RequestMapping("/comment") // 设置该Controller的基础路径为/comment，意味着该控制器下的所有请求路径都以此为前缀
@RequestMapping("/comment")
public class CommentController {
// 自动装配ICommentService，用于调用评论相关的业务逻辑方法，如查询、添加、更新、删除评论等操作。
@Resource
private ICommentService commentService;
// 自动装配IUserService，用于获取用户相关信息，例如根据用户ID查找用户详细信息等操作，辅助评论业务逻辑处理，比如补充评论中的用户信息。
@Resource
private IUserService userService;
// 自动装配IMovieService，用于处理电影相关业务，比如更新电影的评论数量等操作，与评论业务存在关联关系，因为评论是针对电影发表的。
@Resource
private IMovieService movieService;
/**
* 查询所有评论，并将评论中的用户信息补充完整。
* 遍历获取到的所有评论列表，通过用户服务根据评论中的用户ID查找对应的用户详细信息，然后设置到评论对象中，
* 最后将包含完整用户信息的评论列表及相关状态信息封装成 JSON 对象返回给前端。
*
* @return 包含所有评论及其用户信息的JSON对象，其中包含状态码、消息、评论总数以及评论数据等字段信息。
*/
@RequestMapping("findAllComments")
@ResponseBody
public JSONObject findAllComments() {
JSONObject obj = new JSONObject();
// 调用评论服务的方法获取所有评论列表
List<Comment> list = commentService.findAllComments();
for (Comment comment : list) {
// 通过用户服务，根据评论中记录的用户ID查找对应的用户对象，并设置到评论对象中，补充用户信息。
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
obj.put("code", 0); // 设置成功状态码，表示查询操作成功执行。
obj.put("msg", ""); // 无额外消息，此处可根据实际业务需求在有特殊情况时设置相应提示消息。
obj.put("count", list.size()); // 设置评论总数，即获取到的评论列表的大小。
obj.put("data", list); // 将包含完整用户信息的评论列表数据放入 "data" 字段返回给前端。
return obj;
}
/**
* 分页查询评论，支持关键字搜索，并将评论中的用户信息补充完整。
* 先调用评论服务的分页查询方法，根据传入的页码、每页显示数量以及关键词获取评论信息分页结果，
* 然后遍历该分页评论列表，补充其中的用户信息，最后将相关信息封装成 JSON 对象返回给前端，方便前端进行分页展示及数据展示。
*
* @param page 当前页码，默认值为1，如果请求中未传递则使用该默认值，用于指定要获取的评论分页页码。
* @param limit 每页显示数量，默认值为10，如果请求中未传递则使用该默认值，用于指定每页显示的评论条数。
* @param keyword 搜索关键词，可为空字符串，用于对评论内容等进行模糊搜索筛选。
* @return 包含分页评论及其用户信息的JSON对象，包含状态码、消息、总记录数以及分页后的评论数据等字段信息。
*/
@RequestMapping("findAllCommentsPage")
@ResponseBody
public JSONObject findAllCommentsPage(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit, String keyword) {
// 调用评论服务的分页查询方法，传入页码、每页显示数量以及关键词，获取符合条件的评论信息分页结果。
PageInfo<Comment> info = commentService.findAllCommentsBySplitPage(page, limit, keyword);
for (Comment comment : info.getList()) {
// 通过用户服务，根据评论中记录的用户ID查找对应的用户对象，并设置到评论对象中，补充用户信息。
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0); // 设置成功状态码，表示分页查询操作成功执行。
obj.put("msg", ""); // 无额外消息，此处可根据实际业务需求在有特殊情况时设置相应提示消息。
obj.put("count", info.getTotal()); // 设置总记录数，即符合条件的评论总条数，从分页信息对象中获取。
obj.put("data", info.getList()); // 将包含完整用户信息的分页评论列表数据放入 "data" 字段返回给前端。
return obj;
}
/**
* 用户发表评论。
* 首先从请求会话中获取当前用户信息，若用户未登录则返回相应提示信息告知用户需登录后才能评论；
* 若用户已登录，则创建评论对象，设置评论内容、关联的电影ID、用户ID以及评论时间等属性，
* 然后调用评论服务的添加评论方法将评论保存到数据库中，同时调用电影服务的方法更新对应电影的评论数量，
* 根据添加评论和更新电影评论数的操作结果返回相应提示信息给前端。
*
* @param movie_id 电影ID，用于指定该评论关联的电影，表明是对哪部电影发表的评论。
* @param comment_content 评论内容，用户输入的具体评论文字信息。
* @param request 包含用户会话信息的请求对象，用于获取当前登录用户信息等操作。
* @return 包含操作结果的JSON对象，包含状态码和提示消息等字段，告知前端评论发表是否成功。
*/
@RequestMapping("addCommentByUser")
@ResponseBody
public JSONObject addCommentByUser(@RequestParam("movie_id") long movie_id,
@RequestParam("comment_content") String comment_content, HttpServletRequest request) {
User user = (User) request.getSession().getAttribute("user");
JSONObject obj = new JSONObject();
if (user == null) {
// 用户未登录时，设置状态码为200，并返回相应提示消息给前端，告知用户需登录后才可评论。
obj.put("code", 200);
obj.put("msg", "您未登录,登录之后才可评论~");
} else {
Comment comment = new Comment();
comment.setComment_content(comment_content);
comment.setMovie_id(movie_id);
comment.setUser_id(user.getUser_id());
comment.setComment_time(new Date());
// 调用评论服务的添加评论方法，将构建好的评论对象保存到数据库中，返回受影响的行数（通常大于 0 表示添加成功）。
Integer rs = commentService.addComemnt(comment);
if (rs > 0) {
// 如果评论添加成功，调用电影服务的方法更新对应电影（通过评论中的电影ID获取）的评论数量，返回受影响的行数（通常大于 0 表示更新成功）。
Integer rs2 = movieService.addCommentCount(comment.getMovie_id());
if (rs2 > 0) {
obj.put("code", 0); // 设置成功状态码，表示评论发表及电影评论数更新均成功。
obj.put("msg", "评论成功~");
} else {
// 如果电影评论数更新失败，设置相应状态码和提示消息，告知前端评论发表部分成功，但电影评论数更新失败。
obj.put("code", 200);
obj.put("msg", "评论失败2~");
}
} else {
// 如果评论添加失败，设置相应状态码和提示消息，告知前端评论发表失败。
obj.put("code", 200);
obj.put("msg", "评论失败~");
}
}
return obj;
}
/**
* 更新评论内容。
* 先根据传入的评论ID查找对应的评论对象，更新评论的时间（此处可能是更新操作的时间记录）和内容属性，
* 然后调用评论服务的更新评论方法将修改后的评论信息保存到数据库中，根据更新结果返回相应提示信息给前端，告知更新是否成功。
*
* @param comment_id 评论ID，用于唯一标识要更新的评论对象。
* @param comment_content 新的评论内容，用户输入的修改后的评论文字信息。
* @return 包含操作结果的JSON对象，包含状态码和提示消息等字段，告知前端评论内容更新是否成功。
*/
@RequestMapping("updateComment")
@ResponseBody
public JSONObject updateComment(@RequestParam("comment_id") long comment_id,
@RequestParam("comment_content") String comment_content) {
JSONObject obj = new JSONObject();
// 根据评论ID调用评论服务的方法查找对应的评论对象。
Comment comment = this.commentService.findCommentById(comment_id);
comment.setComment_time(new Date());
comment.setComment_content(comment_content);
// 调用评论服务的更新评论方法，将修改后的评论对象保存到数据库中，返回受影响的行数（通常大于 0 表示更新成功）。
Integer rs = commentService.updateComment(comment);
if (rs > 0) {
obj.put("code", 0); // 设置成功状态码，表示评论内容更新成功。
obj.put("msg", "修改成功~");
} else {
// 如果更新失败，设置相应状态码和提示消息，告知前端评论内容更新失败。
obj.put("code", 200);
obj.put("msg", "修改失败~");
}
return obj;
}
/**
* 删除评论，并更新电影评论数。
* 先根据传入的评论ID查找对应的评论对象，获取其关联的电影ID，然后调用电影服务的方法减少对应电影的评论数量，
* 再调用评论服务的删除评论方法将评论从数据库中删除，根据删除操作结果返回相应提示信息给前端，告知删除是否成功。
*
* @param comment_id 评论ID，用于唯一标识要删除的评论对象。
* @return 包含操作结果的JSON对象，包含状态码和提示消息等字段，告知前端评论删除是否成功。
*/
@RequestMapping("deleteComemnt")
@ResponseBody
public JSONObject deleteComment(@RequestParam("comment_id") long comment_id) {
JSONObject obj = new JSONObject();
// 先获取评论关联的电影ID，通过评论服务根据评论ID查找评论对象，再获取其中的电影ID。
Integer rs2 = movieService.delCommentCount(commentService.findCommentById(comment_id).getMovie_id());
// 调用评论服务的删除评论方法，根据评论ID将评论从数据库中删除，返回受影响的行数（通常大于 0 表示删除成功）。
Integer rs = commentService.deleteComment(comment_id);
if (rs > 0) {
obj.put("code", 0); // 设置成功状态码，表示评论删除成功。
obj.put("msg", "删除成功~");
} else {
// 如果删除失败，设置相应状态码和提示消息，告知前端评论删除失败。
obj.put("code", 200);
obj.put("msg", "删除失败~");
}
return obj;
}
/**
* 根据用户名分页查询评论，并将评论中的用户信息补充完整。
* 先调用评论服务的分页查询方法，根据传入的页码、每页显示数量以及用户名获取评论信息分页结果，
* 然后遍历该分页评论列表，补充其中的用户信息，最后将相关信息封装成 JSON 对象返回给前端，方便前端按用户名进行分页展示及数据展示。
*
* @param page 当前页码，默认值为1，如果请求中未传递则使用该默认值，用于指定要获取的评论分页页码。
* @param limit 每页显示数量，默认值为10，如果请求中未传递则使用该默认值，用于指定每页显示的评论条数。
* @param user_name 用户名，用于筛选出该用户发表的评论信息进行分页查询展示。
* @return 包含分页评论及其用户信息的JSON对象，包含状态码、消息、总记录数以及分页后的评论数据等字段信息。
*/
@RequestMapping("findCommentsByUserName")
@ResponseBody
public JSONObject findCommentsByUserName(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit, @RequestParam("user_name") String user_name) {
// 调用评论服务的分页查询方法，传入页码、每页显示数量以及用户名，获取符合条件的评论信息分页结果。
PageInfo<Comment> info = commentService.findCommentsByUserName(page, limit, user_name);
for (Comment comment : info.getList()) {
// 通过用户服务，根据评论中记录的用户ID查找对应的用户对象，并设置到评论对象中，补充用户信息。
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0); // 设置成功状态码，表示按用户名分页查询操作成功执行。
obj.put("msg", ""); // 无额外消息，此处可根据实际业务需求在有特殊情况时设置相应提示消息。
obj.put("count", info.getTotal()); // 设置总记录数，即符合用户名筛选条件的评论总条数，从分页信息对象中获取。
obj.put("data", info.getList()); // 将包含完整用户信息的分页评论列表数据放入 "data" 字段返回给前端。
return obj;
}
}
@Resource
private ICommentService commentService;
@Resource
private IUserService userService;
@Resource
private IMovieService movieService;
//用户： 修改评论、增加评论
//管理员：x 删除评论、 修改评论
//x查询用户的评论
@RequestMapping("findAllComments")
@ResponseBody
public JSONObject findAllComments() {
JSONObject obj = new JSONObject();
List<Comment> list = commentService.findAllComments();
for(Comment comment: list) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
obj.put("code", 0);
obj.put("msg","");
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
//测试 info.getTotal
@RequestMapping("findAllCommentsPage")
@ResponseBody
public JSONObject findAllCommentsPage(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,String keyword) {
PageInfo<Comment> info = commentService.findAllCommentsBySplitPage(page, limit, keyword);
//System.out.println(info);
for(Comment comment : info.getList()) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
@RequestMapping("addCommentByUser")
@ResponseBody
public JSONObject addCommentByUser(@RequestParam("movie_id")long movie_id,@RequestParam("comment_content")String comment_content,HttpServletRequest request) {
User user = (User)request.getSession().getAttribute("user");
JSONObject obj = new JSONObject();
if(user == null) {
obj.put("code",200);
obj.put("msg", "您未登录,登录之后才可评论~");
}else {
Comment comment = new Comment();
comment.setComment_content(comment_content);
comment.setMovie_id(movie_id);
comment.setUser_id(user.getUser_id());
comment.setComment_time(new Date());
Integer rs = commentService.addComemnt(comment);
if(rs > 0) {
Integer rs2 = movieService.addCommentCount(comment.getMovie_id());
if(rs2 > 0) {
obj.put("code", 0);
obj.put("msg", "评论成功~");
}else {
obj.put("code",200);
obj.put("msg", "评论失败2~");
}
}else {
obj.put("code",200);
obj.put("msg", "评论失败~");
}
}
return obj;
}
@RequestMapping("updateComment")
@ResponseBody
public JSONObject updateComment(@RequestParam("comment_id")long comment_id,@RequestParam("comment_content")String comment_content) {
JSONObject obj = new JSONObject();
Comment comment = this.commentService.findCommentById(comment_id);
comment.setComment_time(new Date());
comment.setComment_content(comment_content);
Integer rs = commentService.updateComment(comment);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "修改成功~");
}else {
obj.put("code",200);
obj.put("msg", "修改失败~");
}
return obj;
}
@RequestMapping("deleteComemnt")
@ResponseBody
public JSONObject deleteComment(@RequestParam("comment_id")long comment_id) {
JSONObject obj = new JSONObject();
Integer rs2 = movieService.delCommentCount(commentService.findCommentById(comment_id).getMovie_id());
Integer rs = commentService.deleteComment(comment_id);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "删除成功~");
}else {
obj.put("code", 200);
obj.put("msg", "删除失败~");
}
return obj;
}
@RequestMapping("findCommentsByUserName")
@ResponseBody
public JSONObject findCommentsByUserName(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,@RequestParam("user_name")String user_name) {
PageInfo<Comment> info = commentService.findCommentsByUserName(page, limit, user_name);
//System.out.println(info);
for(Comment comment : info.getList()) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
}

381
src/main/java/com/controller/MovieController.java
Unescape View File

@ -21,215 +21,186 @@ import org.springframework.web.multipart.MultipartFile;
import com.alibaba.fastjson.JSONObject;
import com.entity.Cinema;
import com.entity.Movie;
import com.service.ICinemaService; // 注入电影院服务接口，用于获取电影院相关信息，辅助电影管理业务逻辑
import com.service.IMovieService; // 注入电影服务接口，用于处理电影的各种业务操作，如查询、添加、删除、排序等
import com.util.UUIDUtil; // 用于生成唯一文件名的工具类，在文件上传场景中确保文件名的唯一性
import com.service.ICinemaService;
import com.service.IMovieService;
import com.util.UUIDUtil;
/**
* 电影管理模块，主要负责处理与电影相关的各种业务请求，例如电影详情查询、电影列表展示及筛选排序、电影的添加、删除以及更新等操作。
* 电影管理模块
* @author Wxj
*/
@Controller
@RequestMapping("/movie")
public class MovieController {
// 注入电影服务接口的实现类，通过该接口可以调用电影服务层提供的各种业务方法，实现对电影数据的操作。
@Resource
private IMovieService movieService;
// 注入电影院服务接口的实现类，用于获取电影院相关信息，例如查找放映某部电影的电影院列表等操作，与电影业务存在关联关系。
@Resource
private ICinemaService cinemaService;
// 1.电影详情页，通过电影ID查找电影详情和对应的电影院列表，用于前端展示电影的详细信息以及该电影在哪些电影院上映等情况。
@RequestMapping("findMovieById")
@ResponseBody
public JSONObject findMovieById(@RequestParam("movie_id") long movie_id) {
JSONObject obj = new JSONObject();
// 调用电影服务的方法，根据传入的电影ID查找对应的电影对象，获取电影详情信息。
Movie movie = movieService.findMovieById(movie_id);
// 调用电影院服务的方法，查找放映该电影（通过传入电影ID）的电影院列表。
List<Cinema> list = this.cinemaService.findCinemasByMovieId(movie_id);
obj.put("code", 0);
// 将电影详情数据放入 "data" 字段返回给前端。
obj.put("data", movie);
// 将电影院列表数据放入 "cinemaList" 字段返回给前端，方便前端展示该电影的上映影院信息。
obj.put("cinemaList", list);
// 将电影院列表的大小（即放映该电影的影院数量）放入 "cinemaCount" 字段返回给前端。
obj.put("cinemaCount", list.size());
return obj;
}
// 2.首页电影列表，支持按名称搜索、按类型搜索，以及按时间、参评人数、评分排序，用于前端展示多种条件筛选和排序后的电影列表信息，满足不同用户查找电影的需求。
@RequestMapping("findAllMovies")
@ResponseBody
public JSONObject findAllMovies() {
JSONObject obj = new JSONObject();
// 获取正在上映的电影列表，这里参数 1 可能表示正在上映的筛选条件（具体由服务层方法定义）。
List<Movie> list = movieService.findAllMovies(1);
// 获取即将上映的电影列表，这里参数 0 可能表示即将上映的筛选条件（具体由服务层方法定义）。
List<Movie> upcomingList = movieService.findAllMovies(0);
// 获取按票房排序的电影列表，调用服务层按票房排序电影的方法。
List<Movie> offList = movieService.sortMovieByBoxOffice();
String type[] = {"喜剧", "动作", "爱情", "动画", "科幻", "惊悚", "冒险", "犯罪", "悬疑"};
ArrayList<Object> typeArr = new ArrayList<Object>();
for (int i = 0; i < type.length; i++) {
// 根据电影类型查找对应的电影列表，遍历各种类型进行查询。
List<Movie> movieList = this.movieService.findMoviesLikeType(type[i]);
float boxOffice = 0;
for (int j = 0; j < movieList.size(); j++) {
// 累加该类型电影的票房，用于统计各类型电影的总票房情况。
boxOffice += movieList.get(j).getMovie_boxOffice();
}
JSONObject typeJson = new JSONObject();
// 将电影类型作为键，该类型电影的总票房作为值，放入 JSON 对象中，方便前端按类型展示票房情况。
typeJson.put(type[i], boxOffice);
typeArr.add(typeJson);
}
obj.put("code", 0);
// 设置正在上映电影列表的数量，放入 "count" 字段返回给前端。
obj.put("count", list.size());
// 设置即将上映电影列表的数量，放入 "upcomingCount" 字段返回给前端。
obj.put("upcomingCount", upcomingList.size());
// 将正在上映的电影列表数据放入 "data" 字段返回给前端。
obj.put("data", list);
// 将即将上映的电影列表数据放入 "data1" 字段返回给前端。
obj.put("data1", upcomingList);
// 将按票房排序的电影列表数据放入 "sort" 字段返回给前端。
obj.put("sort", offList);
// 将按类型统计票房的信息列表放入 "type" 字段返回给前端，方便前端展示各类型电影票房情况。
obj.put("type", typeArr);
return obj;
}
// 3.按名称搜索电影，根据用户输入的电影名称查找匹配的电影列表，返回给前端展示搜索结果。
@RequestMapping("findMoviesByName")
@ResponseBody
public JSONObject findMoviesByName(@RequestParam("name") String name) {
JSONObject obj = new JSONObject();
// 调用电影服务的方法，根据传入的电影名称进行模糊查询，获取匹配的电影列表。
List<Movie> list = movieService.findMoviesLikeName(name);
obj.put("code", 0);
// 设置查询到的电影列表的数量，放入 "count" 字段返回给前端。
obj.put("count", list.size());
// 将查询到的电影列表数据放入 "data" 字段返回给前端。
obj.put("data", list);
return obj;
}
// 4.按类型搜索电影，根据用户指定的电影类型查找相应的电影列表，并返回给前端展示搜索结果。
@RequestMapping("findMoviesByType")
@ResponseBody
public JSONObject findMoviesByType(@RequestParam("type") String type) {
JSONObject obj = new JSONObject();
// 调用电影服务的方法，根据传入的电影类型进行模糊查询，获取匹配的电影列表。
List<Movie> list = movieService.findMoviesLikeType(type);
obj.put("code", 0);
// 设置查询到的电影列表的数量，放入 "count" 字段返回给前端。
obj.put("count", list.size());
// 将查询到的电影列表数据放入 "data" 字段返回给前端。
obj.put("data", list);
return obj;
}
// 5.按时间、评价人数、评分排序电影，根据用户选择的排序方式（如热门、时间、评价）对电影列表进行相应排序，并返回给前端展示排序后的结果。
@RequestMapping("sortAllMovies")
@ResponseBody
public JSONObject sortAllMovies(@RequestParam("order") String order) {
JSONObject obj = new JSONObject();
List<Movie> list = new ArrayList<Movie>();
switch (order) {
case "热门":
// 调用电影服务的按评价人数排序电影的方法，获取排序后的电影列表，这里 "热门" 可能对应按评价人数排序（具体由服务层定义）。
list = movieService.sortMovieByCount();
break;
case "时间":
// 调用电影服务的按时间排序电影的方法，获取排序后的电影列表，按照时间先后顺序进行排序。
list = movieService.sortMovieByDate();
break;
case "评价":
// 调用电影服务的按评分排序电影的方法，获取排序后的电影列表，按照电影评分高低进行排序。
list = movieService.sortMovieByScore();
break;
}
obj.put("code", 0);
// 设置排序后电影列表的数量，放入 "count" 字段返回给前端。
obj.put("count", list.size());
// 将排序后的电影列表数据放入 "data" 字段返回给前端。
obj.put("data", list);
return obj;
}
// 6.删除电影，根据传入的电影ID执行删除电影的操作，并根据删除结果返回相应提示信息给前端，告知用户下架是否成功。
@RequestMapping("deleteMovie")
@ResponseBody
public JSONObject deleteMovie(@RequestParam("movie_id") long movie_id) {
JSONObject obj = new JSONObject();
// 调用电影服务的删除电影方法，传入电影ID进行删除操作，返回受影响的行数（通常大于 0 表示删除成功）。
Integer rs = movieService.deleteMovie(movie_id);
if (rs > 0) {
obj.put("code", 0);
obj.put("msg", "下架成功~");
} else {
obj.put("code", 200);
obj.put("msg", "下架失败~");
}
return obj;
}
// 7.添加电影，包括上传电影海报和设置电影信息，处理添加新电影的请求，涉及文件上传、电影基本信息设置以及保存到数据库等操作，根据结果返回相应提示信息给前端。
@RequestMapping("addMovie")
@ResponseBody
public JSONObject addMovie(@RequestParam(value = "file", required = false) MultipartFile file, Movie movie,
HttpServletRequest request) throws IOException {
// 获取上传文件（电影海报）的原始名称，用于记录和后续处理（如生成唯一文件名等操作）。
String str = file.getOriginalFilename();
System.out.println("file:" + str);
// 使用 UUIDUtil 工具类生成唯一文件名，结合原始文件名的后缀，确保文件名在服务器上的唯一性，方便文件管理。
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:" + name);
// 获取文件存储在服务器上的完整路径，结合服务器上下文路径和生成的唯一文件名，确定文件最终存储位置。
String path = request.getServletContext().getRealPath("/upload/movies") + "/" + name;
System.out.println("path:" + path);
// 生成存储在数据库中的相对路径，方便在数据库中记录文件位置，后续可根据此路径查找和展示海报图片。
String filePath = "../upload/movies/" + name;
// 设置电影对象的海报路径属性，将生成的相对路径赋值给电影对象，以便后续保存电影信息时一起存入数据库。
movie.setMovie_picture(filePath);
Date date = new Date();
// 修复获取年份和月份的bug，将 Java 的 Date 类型转换为 java.sql.Date 类型，用于设置电影的上映日期，确保日期格式符合数据库要求。
java.sql.Date releaseDate = new java.sql.Date(date.getYear() + 1900, date.getMonth() + 1, date.getDay());
//SimpleDateFormat dateFormat = new SimpleDateFormat("YYYY-MM-dd");
// 随机生成一个 5 - 9 之间的评分，通过 Random 类生成随机数，并结合一定的计算来控制评分范围。
float random = 5 + (new Random().nextFloat() * 4);
// 使用 DecimalFormat 格式化评分数字，使其保留一位小数，符合常见的评分展示格式要求。
DecimalFormat fnum = new DecimalFormat("##0.0");
String score = fnum.format(random);
// 将格式化后的评分设置为电影对象的评分属性，更新电影的评分信息。
movie.setMovie_score(Float.parseFloat(score));
// 设置电影对象的上映日期属性，将前面生成的符合数据库要求的日期赋值给电影对象，完善电影信息。
movie.setReleaseDate(releaseDate);
// 调用电影服务的添加电影方法，将包含完整信息（包括海报路径、评分、上映日期等）的电影对象保存到数据库中，返回受影响的行数（通常大于 0 表示添加成功）。
Integer rs = movieService.addMovie(movie);
JSONObject obj = new JSONObject();
if (rs > 0) {
// 如果添加电影成功，将上传的文件保存到指定路径，即将电影海报文件存储到服务器相应位置。
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
obj.put("code", 0);
obj.put("msg", "添加成功~");
} else {
obj.put("code", 200);
obj.put("msg", "添加失败~");
}
return obj;
}
// 8.更新电影，这里可能后续需要补充具体的更新电影逻辑代码，目前只是一个方法定义的占位，比如接收更新后的电影信息，调用服务层的更新方法等操作。
@RequestMapping("updateMovie")
@ResponseBody
public JSONObject updateMovie() {
// 此处代码暂未实现具体逻辑，后续可根据业务需求添加更新电影信息的相关代码，例如接收前端传入的更新后的电影对象，
// 调用 movieService 的相应更新方法进行数据库更新操作，并根据更新结果返回合适的提示信息给前端等操作。
JSONObject obj = new JSONObject();
return obj;
}
}
@Resource
private IMovieService movieService;
@Resource
private ICinemaService cinemaService;
//1.电影详情页 findid
//2.首页电影列表 + name搜索 + type搜素 + 时间、参评人数、评分排序
//3.增加、删除、修改
@RequestMapping("findMovieById")
@ResponseBody
public JSONObject findMovieById(@RequestParam("movie_id")long movie_id) {
JSONObject obj = new JSONObject();
Movie movie = movieService.findMovieById(movie_id);
List<Cinema> list = this.cinemaService.findCinemasByMovieId(movie_id);
obj.put("code", 0);
obj.put("data", movie);
obj.put("cinemaList",list);
obj.put("cinemaCount",list.size());
return obj;
}
@RequestMapping("findAllMovies")
@ResponseBody
public JSONObject findAllMovies() {
JSONObject obj = new JSONObject();
List<Movie> list = movieService.findAllMovies(1);
List<Movie> upcomingList = movieService.findAllMovies(0);
List<Movie> offList = movieService.sortMovieByBoxOffice();
String type[] = {"喜剧","动作","爱情","动画","科幻","惊悚","冒险","犯罪","悬疑"};
ArrayList<Object> typeArr = new ArrayList<Object>();
for(int i = 0;i < type.length;i++) {
List<Movie> movieList = this.movieService.findMoviesLikeType(type[i]);
float boxOffice = 0;
for(int j = 0; j < movieList.size();j++) {
boxOffice += movieList.get(j).getMovie_boxOffice();
}
JSONObject typeJson = new JSONObject();
typeJson.put(type[i], boxOffice);
typeArr.add(typeJson);
}
obj.put("code", 0);
obj.put("count", list.size());
obj.put("upcomingCount",upcomingList.size());
obj.put("data", list);
obj.put("data1", upcomingList);
obj.put("sort", offList);
obj.put("type", typeArr);
return obj;
}
@RequestMapping("findMoviesByName")
@ResponseBody
public JSONObject findMoviesByName(@RequestParam("name") String name) {
JSONObject obj = new JSONObject();
List<Movie> list = movieService.findMoviesLikeName(name);
obj.put("code", 0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("findMoviesByType")
@ResponseBody
public JSONObject findMoviesByType(@RequestParam("type") String type) {
JSONObject obj = new JSONObject();
List<Movie> list = movieService.findMoviesLikeType(type);
obj.put("code", 0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("sortAllMovies")
@ResponseBody
public JSONObject sortAllMovies(@RequestParam("order") String order) {
JSONObject obj = new JSONObject();
List<Movie> list = new ArrayList<Movie>();
switch (order) {
case "热门":
list = movieService.sortMovieByCount();
break;
case "时间":
list = movieService.sortMovieByDate();
break;
case "评价":
list = movieService.sortMovieByScore();
break;
}
obj.put("code",0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("deleteMovie")
@ResponseBody
public JSONObject deleteMovie(@RequestParam("movie_id") long movie_id) {
JSONObject obj = new JSONObject();
Integer rs = movieService.deleteMovie(movie_id);
if(rs > 0) {
obj.put("code",0);
obj.put("msg","下架成功~");
}else {
obj.put("code", 200);
obj.put("msg", "下架失败~");
}
return obj;
}
@RequestMapping("addMovie")
@ResponseBody
public JSONObject addMovie(@RequestParam(value="file",required=false) MultipartFile file,Movie movie,HttpServletRequest request) throws IOException {
String str = file.getOriginalFilename();
System.out.println("file:" + str);
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:" + name);
String path = request.getServletContext().getRealPath("/upload/movies") + "/" + name;
System.out.println("path:" + path);
String filePath = "../upload/movies/" + name;
movie.setMovie_picture(filePath);
Date date = new Date();
java.sql.Date releaseDate = new java.sql.Date(date.getYear(), date.getMonth(), date.getDay());
//SimpleDateFormat dateFormat = new SimpleDateFormat("YYYY-MM-dd");
float random = 5 + (new Random().nextFloat() * 4);
DecimalFormat fnum = new DecimalFormat("##0.0");
String score = fnum.format(random);
movie.setMovie_score(Float.parseFloat(score));
movie.setReleaseDate(releaseDate);
Integer rs = movieService.addMovie(movie);
JSONObject obj = new JSONObject();
if(rs > 0) {
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
obj.put("code", 0);
obj.put("msg", "添加成功~");
}else {
obj.put("code", 200);
obj.put("msg", "添加失败~");
}
return obj;
}
@RequestMapping("updateMovie")
@ResponseBody
public JSONObject updateMovie(@RequestParam(value="file",required=false)MultipartFile file,Movie movie,HttpServletRequest request) throws IOException{
JSONObject obj = new JSONObject();
if(file != null) {
String str = file.getOriginalFilename();
System.out.println("file:" + str);
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:" + name);
String path = request.getServletContext().getRealPath("/upload/movies") + "/" + name;
System.out.println("path:" + path);
String filePath = "../upload/movies/" + name;
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
movie.setMovie_picture(filePath);
}else {
Movie oldMovie = this.movieService.findMovieById(movie.getMovie_id());
movie.setMovie_picture(oldMovie.getMovie_picture());
}
Integer rs = movieService.updateMovie(movie);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "修改成功~");
}else {
obj.put("code", 200);
obj.put("msg", "修改失败~");
}
return obj;
}
}

385
src/main/java/com/controller/OrderController.java
Unescape View File

@ -21,206 +21,191 @@ import com.service.IMovieService;
import com.service.IOrderService;
import com.service.IScheduleService;
// 声明这是一个Spring MVC控制器，处理与订单相关的请求，RequestMapping注解指定了该控制器处理请求的基础路径为 "/order"
@Controller
@RequestMapping("/order")
public class OrderController {
// 注入订单服务，用于处理订单相关的业务逻辑，例如订单的查询、添加、修改等操作
@Resource
private IOrderService orderService;
// 注入排期服务，用于处理排期（如座位状态）的更新，比如在支付、退票成功等操作时对相应场次座位数进行增减操作
@Resource
private IScheduleService scheduleService;
// 支付、退票成功时座位数的增减相关操作会调用此服务提供的方法来实现
// 注入电影服务，用于处理电影票房的更新，在支付、退票成功等场景下对电影票房数据进行相应的增减操作
@Resource
private IMovieService movieService;
// 根据订单ID查找订单详情，并返回给前端，前端可根据返回结果展示订单的详细信息
@RequestMapping("findOrderById")
@ResponseBody
public JSONObject findOrderById(@RequestParam("order_id") String order_id) {
JSONObject obj = new JSONObject();
// 调用订单服务的方法，根据传入的订单ID查找对应的订单对象
Order order = orderService.findOrderById(order_id);
List<Order> list = new ArrayList<>();
list.add(order);
// 设置返回的状态码为0，表示查找成功
obj.put("code", 0);
obj.put("msg", "");
// 设置返回数据的数量，这里因为只查找了一个订单，所以数量为1（即list的大小）
obj.put("count", list.size());
// 将查找到的订单数据放入 "data" 字段返回给前端
obj.put("data", list);
return obj;
}
// 根据用户名分页查找订单，并返回给前端，方便前端按照分页形式展示该用户的订单信息
@RequestMapping("findOrderByUserName")
@ResponseBody
public JSONObject findOrderByUserName(
@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit,
@RequestParam("user_name") String user_name) {
// 调用订单服务的分页查询方法，根据传入的页码、每页显示数量以及用户名查找对应的订单信息分页结果
PageInfo<Order> info = orderService.findOrdersByUserName(page, limit, user_name);
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
// 设置总记录数，即符合条件的订单总数，从分页信息对象中获取
obj.put("count", info.getTotal());
// 将分页后的订单列表数据放入 "data" 字段返回给前端
obj.put("data", info.getList());
return obj;
}
// 根据用户名查找用户的退票订单，并返回给前端，用于前端展示该用户的退票相关订单信息
@RequestMapping("findRefundOrderByUser")
@ResponseBody
public JSONObject findRefundOrderByUser(@RequestParam("user_name") String user_name) {
JSONObject obj = new JSONObject();
// 调用订单服务的方法，根据用户名查找该用户的退票订单列表
List<Order> list = this.orderService.findRefundOrderByUserName(user_name);
obj.put("code", 0);
obj.put("msg", "");
// 设置退票订单的数量，即列表的大小
obj.put("count", list.size());
// 将查找到的退票订单列表数据放入 "data" 字段返回给前端
obj.put("data", list);
return obj;
}
// 查找所有订单，并返回给前端，可用于前端展示系统中所有的订单信息（可能用于管理后台等场景）
@RequestMapping("findAllOrders")
@ResponseBody
public JSONObject findAllOrders() {
JSONObject obj = new JSONObject();
// 调用订单服务的方法获取所有订单列表
List<Order> list = orderService.findAllOrders();
obj.put("code", 0);
obj.put("msg", "");
// 设置所有订单的数量，即列表的大小
obj.put("count", list.size());
// 将所有订单列表数据放入 "data" 字段返回给前端
obj.put("data", list);
return obj;
}
// 根据关键词分页查找所有订单，并返回给前端，方便前端按照分页形式展示经过关键词筛选后的订单信息
@RequestMapping("findAllOrdersPage")
@ResponseBody
public JSONObject findAllOrdersPage(
@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit,
String keyword) {
// 调用订单服务的分页查询方法，根据传入的页码、每页显示数量以及关键词查找对应的订单信息分页结果
PageInfo<Order> info = orderService.findAllOrdersBySplitPage(page, limit, keyword);
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
// 设置总记录数，即符合关键词筛选条件的订单总数，从分页信息对象中获取
obj.put("count", info.getTotal());
// 将分页后的订单列表数据放入 "data" 字段返回给前端
obj.put("data", info.getList());
return obj;
}
// 查找所有退票订单，并返回给前端（分页），用于前端分页展示系统中的所有退票订单信息（可能用于统计、管理等场景）
@RequestMapping("findAllRefundOrder")
@ResponseBody
public JSONObject findAllRefundOrder(
@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit) {
JSONObject obj = new JSONObject();
// 调用订单服务的方法，根据页码和每页显示数量查找处于退票状态（这里0可能表示退票状态）的订单信息分页结果
PageInfo<Order> info = orderService.findOrdersByState(page, limit, 0);
obj.put("code", 0);
obj.put("msg", "");
// 设置总记录数，即符合退票状态筛选条件的订单总数，从分页信息对象中获取
obj.put("count", info.getTotal());
// 将分页后的退票订单列表数据放入 "data" 字段返回给前端
obj.put("data", info.getList());
return obj;
}
// 购买电影票的逻辑处理，接收排期ID、座位信息、票价以及HttpServletRequest对象等参数，完成订单创建、座位数更新等操作
@RequestMapping("buyTickets")
@ResponseBody
public JSONObject buyTickets(
@RequestParam("schedule_id") long schedule_id,
@RequestParam("position[]") String[] position,
@RequestParam("price") int price,
HttpServletRequest request) {
// 从会话中获取当前用户，用于确定购票的用户信息，若未登录则无法购票
User user = (User) request.getSession().getAttribute("user");
JSONObject obj = new JSONObject();
if (user == null) {
// 用户未登录时，设置状态码为200，并返回相应提示消息给前端，告知用户需登录后才可购票
obj.put("code", 200);
obj.put("msg", "您未登录,登录之后才可购票~");
} else {
int done = 0; // 记录成功购买的座位数，初始化为0
// 计算每个座位的单价，用总票价除以购买的座位数量
int order_price = price / position.length;
String user_id = ""; // 格式化后的用户ID，初始化为空字符串，后续根据用户ID长度进行格式化处理
// 根据用户ID的长度进行格式化，确保用户ID格式统一，可能用于生成订单ID等逻辑需要
switch (String.valueOf(user.getUser_id()).length()) {
case 1: user_id = "000" + String.valueOf(user.getUser_id()); break;
case 2: user_id = "00" + String.valueOf(user.getUser_id()); break;
case 3: user_id = "0" + String.valueOf(user.getUser_id()); break;
case 4: user_id = String.valueOf(user.getUser_id()); break;
}
// 遍历要购买的座位数组，为每个座位创建订单并进行相关业务逻辑处理
for (int i = 0; i < position.length; i++) {
Order order = new Order();
String order_id = "";
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("YYYYMMdd");
// 生成订单ID，格式为（日期+用户ID+座位索引），先添加日期部分
order_id += dateFormat.format(date);
order_id += user_id;
String index = "";
// 根据座位字符串的长度进行不同的格式化处理，提取出座位索引部分，用于生成订单ID
switch (position[i].length()) {
case 4:
index = "0" + position[i].replaceAll("排", "0");
index = index.replaceAll("座", "");
break;
case 5:
if (position[i].charAt(2) >= 48 && position[i].charAt(2) <= 57) {
index = "0" + position[i].replaceAll("排", "");
index = index.replaceAll("座", "");
} else {
index = position[i].replaceAll("排", "0");
index = index.replaceAll("座", "");
}
break;
case 6:
index = position[i].replaceAll("排", "");
index = index.replaceAll("座", "");
break;
}
order_id += index;
// 设置订单对象的各项属性，如订单ID、座位位置、对应的排期ID、用户ID、单价以及下单时间等
order.setOrder_id(order_id);
order.setOrder_position(position[i]);
order.setSchedule_id(schedule_id);
order.setUser_id(user.getUser_id());
order.setOrder_price(order_price);
order.setOrder_time(new Date());
// 添加订单到数据库，调用订单服务的添加订单方法
Integer rs = this.orderService.addOrder(order);
// 更新排期的剩余座位数，调用排期服务的相应方法减少剩余座位数，每成功添加一个订单就减少一个座位
Integer rs1 = this.scheduleService.delScheduleRemain(schedule_id);
done++;
}
// 此处代码可能还需要处理一些后续逻辑，比如判断所有座位是否都购买成功（根据done与position.length对比），
// 以及是否需要更新电影票房（调用movieService相关方法）等操作，目前代码似乎未完整展示这些逻辑。
}
return obj;
}
}
@Resource
private IOrderService orderService;
@Resource
private IScheduleService scheduleService; //支付、退票成功 座位+-
@Resource
private IMovieService movieService; //支付、退票成功 票房+-
//查看订单是否 是支付的（返回给前端的数据）
@RequestMapping("findOrderById")
@ResponseBody
public JSONObject findOrderById(@RequestParam("order_id")String order_id) {
JSONObject obj = new JSONObject();
Order order = orderService.findOrderById(order_id);
List<Order> list = new ArrayList<Order>();
list.add(order);
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", list.size());
obj.put("data",list);
return obj;
}
@RequestMapping("findOrderByUserName")
@ResponseBody
public JSONObject findOrderByUserName(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,@RequestParam("user_name")String user_name) {
PageInfo<Order> info = orderService.findOrdersByUserName(page, limit, user_name);
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
@RequestMapping("findRefundOrderByUser")
@ResponseBody
public JSONObject findRefundOrderByUser(@RequestParam("user_name")String user_name) {
JSONObject obj = new JSONObject();
List<Order> list = this.orderService.findRefundOrderByUserName(user_name);
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("findAllOrders")
@ResponseBody
public JSONObject findAllOrders() {
JSONObject obj = new JSONObject();
List<Order> list = orderService.findAllOrders();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("findAllOrdersPage")
@ResponseBody
public JSONObject findAllOrdersPage(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,String keyword) {
PageInfo<Order> info = orderService.findAllOrdersBySplitPage(page, limit, keyword);
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
@RequestMapping("findAllRefundOrder")
@ResponseBody
public JSONObject findAllRefundOrder(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit) {
JSONObject obj = new JSONObject();
PageInfo<Order> info = orderService.findOrdersByState(page, limit, 0);
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
@RequestMapping("buyTickets")
@ResponseBody
public JSONObject buyTickets(@RequestParam("schedule_id")long schedule_id,@RequestParam("position[]")String[] position,@RequestParam("price")int price,HttpServletRequest request) {
User user = (User)request.getSession().getAttribute("user");
JSONObject obj = new JSONObject();
if(user == null) {
obj.put("code",200);
obj.put("msg", "您未登录,登录之后才可购票~");
}else {
int done = 0;
int order_price = price / position.length;
String user_id = "";
switch(String.valueOf(user.getUser_id()).length()) {
case 1: user_id = "000" + String.valueOf(user.getUser_id()); break;
case 2: user_id = "00" + String.valueOf(user.getUser_id()); break;
case 3: user_id = "0" + String.valueOf(user.getUser_id()); break;
case 4: user_id = String.valueOf(user.getUser_id()); break;
}
for(int i = 0;i < position.length;i++) {
Order order = new Order();
String order_id = "";
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("YYYYMMdd");
order_id += dateFormat.format(date);
order_id += user_id;
String index = "";
switch(position[i].length()) {
case 4:
index = "0" + position[i].replaceAll("排", "0");
index = index.replaceAll("座", "");
break;
case 5:
if(position[i].charAt(2) >= 48 && position[i].charAt(2) <= 57) {
index = "0" + position[i].replaceAll("排", "");
index = index.replaceAll("座", "");
}else {
index = position[i].replaceAll("排", "0");
index = index.replaceAll("座", "");
}
break;
case 6:
index = position[i].replaceAll("排", "");
index = index.replaceAll("座", "");
break;
}
order_id += index;
order.setOrder_id(order_id);
order.setOrder_position(position[i]);
order.setSchedule_id(schedule_id);
order.setUser_id(user.getUser_id());
order.setOrder_price(order_price);
order.setOrder_time(new Date());
Integer rs = this.orderService.addOrder(order);
Integer rs1 = this.scheduleService.delScheduleRemain(schedule_id);
done++;
}
if(done == position.length) {
float sum = (float)price/10000;
Integer rs2 = this.movieService.changeMovieBoxOffice(sum, this.scheduleService.findScheduleById(schedule_id).getMovie_id());
obj.put("code",0);
obj.put("msg", "购票成功~");
}else {
obj.put("code",200);
obj.put("msg", "购票失败~");
}
}
return obj;
}
@RequestMapping("applyForRefund")
@ResponseBody
public JSONObject applyForRefund(@RequestParam("order_id")String order_id) {
JSONObject obj = new JSONObject();
Integer rs = orderService.updateOrderStateToRefund(order_id);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "退票申请已发送~");
}else {
obj.put("code", 200);
obj.put("msg", "操作失败~");
}
return obj;
}
@RequestMapping("agreeForRefund")
@ResponseBody
public JSONObject agreeForRefund(@RequestParam("order_id")String order_id) {
JSONObject obj = new JSONObject();
Integer rs = this.orderService.updateOrderStateToRefunded(order_id);
if(rs > 0) {
Order order = this.orderService.findOrderById(order_id);
int price = order.getOrder_price();
long movie_id = order.getOrder_schedule().getMovie_id();
Integer rs2 = this.movieService.changeMovieBoxOffice((float)price/10000, movie_id);
obj.put("code", 0);
obj.put("msg", "退票成功");
}else {
obj.put("code", 200);
obj.put("msg", "退票失败");
}
return obj;
}
}

495
src/main/java/com/controller/ScheduleController.java
Unescape View File

@ -23,282 +23,225 @@ import com.service.IHallService;
import com.service.IMovieService;
import com.service.IScheduleService;
/**
* 场次（Schedule）相关业务的控制器类，主要负责处理与电影场次相关的各种请求，
* 例如查询场次信息、根据不同条件筛选场次、添加场次、修改场次价格以及下架场次等操作。
* 通过依赖注入各个相关服务层接口，调用对应的服务方法来实现具体业务逻辑，
* 并将结果以 JSON 格式返回给前端页面或其他调用方。
*/
@Controller
@RequestMapping("/schedule")
public class ScheduleController {
// 注入场次服务层接口，用于调用场次相关的业务逻辑方法，如查询、添加、修改、删除场次等操作。
@Resource
private IScheduleService scheduleService;
// 注入电影服务层接口，用于获取电影相关信息，例如根据电影名查找电影编号等操作，辅助场次相关业务逻辑处理。
@Resource
private IMovieService movieService;
// 注入影院服务层接口，用于获取影院相关信息，可能在查询场次与影院关联等业务场景中使用。
@Resource
private ICinemaService cinemaService;
// 注入放映厅服务层接口，用于获取放映厅相关信息，比如根据影院和放映厅名称查找放映厅等操作，与场次的关联查询等业务有关。
@Resource
private IHallService hallService;
/**
* 根据场次编号查找场次信息的方法，处理根据唯一标识符查询场次详情的请求。
* 接收场次编号作为参数，调用 scheduleService 的查询方法获取对应的场次对象，
* 将查询结果封装到 JSONObject 中，设置状态码为 0，并将场次数据放入 "data" 字段后返回。
*
* @param schedule_id 要查询的场次的唯一标识符。
* @return JSONObject 包含场次查询结果信息的 JSON 对象，其中 "code" 表示状态码，"data" 存放场次对象信息。
*/
@RequestMapping("findScheduleById")
@ResponseBody
public JSONObject findScheduleById(@RequestParam("schedule_id") long schedule_id) {
JSONObject obj = new JSONObject();
Schedule schedule = scheduleService.findScheduleById(schedule_id);
obj.put("code", 0);
obj.put("data", schedule);
return obj;
}
/**
* 根据场次状态分页查询场次信息的方法，处理按场次状态筛选场次并分页展示的请求。
* 接收页码、每页显示数量以及场次状态作为参数，调用 scheduleService 的对应方法获取符合条件的场次信息分页结果。
* 同时，遍历场次列表，计算每个场次对应的订单收入总和，将收入数据存入 incomeArr 列表中。
* 最后将状态码、总记录数、场次列表以及收入列表等信息封装到 JSONObject 中返回。
*
* @param page 当前页码，默认值为 1，如果请求中未传递则使用该默认值。
* @param limit 每页显示的场次数量，默认值为 10，如果请求中未传递则使用该默认值。
* @param schedule_state 用于筛选场次的状态值，例如 1 表示上映中，0 表示下架等。
* @return JSONObject 包含按状态分页查询场次结果相关信息的 JSON 对象，包含 "code"（状态码）、"count"（总记录数）、"data"（场次列表）、"income"（各场次收入列表）等字段。
*/
@RequestMapping("findAllScheduleByState")
@ResponseBody
public JSONObject findAllScheduleByState(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit,
@RequestParam("schedule_state") int schedule_state) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findAllScheduleByState(page, limit, schedule_state);
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for (int j = 0; j < info.getList().size(); j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for (int i = 0; i < orderList.size(); i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("income", incomeArr);
return obj;
}
/**
* 分页查询所有场次信息的方法，处理查询所有场次信息并进行相关综合数据整合的请求。
* 接收页码和每页显示数量作为参数，调用 scheduleService 的方法获取场次信息分页结果。
* 同时，获取所有正在上映的电影列表、所有影院列表，计算每个场次的收入总和，整理出电影名称列表、影院相关信息列表（包含各影院下的放映厅名称列表）以及收入列表等。
* 最后将这些数据（状态码、总记录数、场次列表、电影名称列表、影院信息列表、收入列表）封装到 JSONObject 中返回。
*
* @param page 当前页码，默认值为 1，如果请求中未传递则使用该默认值。
* @param limit 每页显示的场次数量，默认值为 10，如果请求中未传递则使用该默认值。
* @return JSONObject 包含所有场次查询结果及相关综合信息的 JSON 对象，包含多个字段用于存放不同类型的数据，如 "code"、"count"、"data"、"movieName"、"cinema"、"income" 等。
*/
@RequestMapping("findAllSchedule")
@ResponseBody
public JSONObject findAllSchedule(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findAllSchedule(page, limit);
List<Movie> movieList = movieService.findAllMovies(1);
List<Cinema> cinemaList = cinemaService.findAllCinemas();
ArrayList<String> movieArr = new ArrayList<String>();
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for (int j = 0; j < info.getList().size(); j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for (int i = 0; i < orderList.size(); i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
for (int i = 0; i < movieList.size(); i++) {
movieArr.add(movieList.get(i).getMovie_cn_name());
}
ArrayList<Object> cinema = new ArrayList<>();
for (int i = 0; i < cinemaList.size(); i++) {
JSONObject cinemaObj = new JSONObject();
List<Hall> hallList = hallService.findHallByCinemaId(cinemaList.get(i).getCinema_id());
ArrayList<String> hallArr = new ArrayList<String>();
for (int j = 0; j < hallList.size(); j++) {
hallArr.add(hallList.get(j).getHall_name());
}
cinemaObj.put(cinemaList.get(i).getCinema_name(), hallList);
cinema.add(cinemaObj);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("movieName", movieArr);
obj.put("cinema", cinema);
obj.put("income", incomeArr);
return obj;
}
/**
* 根据电影名称分页查询场次信息的方法，处理按电影名称筛选场次并分页展示的请求。
* 接收页码、每页显示数量以及电影名称作为参数，调用 scheduleService 的对应方法获取符合条件的场次信息分页结果。
* 同样，会计算每个场次对应的订单收入总和，将收入数据存入 incomeArr 列表中，最后将相关信息封装到 JSONObject 中返回。
*
* @param page 当前页码，默认值为 1，如果请求中未传递则使用该默认值。
* @param limit 每页显示的场次数量，默认值为 10，如果请求中未传递则使用该默认值。
* @param movie_name 用于筛选场次的电影名称。
* @return JSONObject 包含按电影名称分页查询场次结果相关信息的 JSON 对象，包含 "code"、"count"、"data"、"income" 等字段用于传递相应数据。
*/
@RequestMapping("findScheduleByMovieName")
@ResponseBody
public JSONObject findScheduleByMovieName(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit,
@RequestParam("movie_name") String movie_name) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findScheduleByMovieName(page, limit, movie_name);
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for (int j = 0; j < info.getList().size(); j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for (int i = 0; i < orderList.size(); i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("income", incomeArr);
return obj;
}
/**
* 根据电影名称分页查询已下架场次信息的方法，处理按电影名称筛选已下架场次并分页展示的请求。
* 与 findScheduleByMovieName 类似，接收页码、每页显示数量以及电影名称作为参数，调用 scheduleService 的对应方法获取符合条件的已下架场次信息分页结果，
* 计算各场次收入并存入 incomeArr 列表，最后将相关信息封装到 JSONObject 中返回。
*
* @param page 当前页码，默认值为 1，如果请求中未传递则使用该默认值。
* @param limit 每页显示的场次数量，默认值为 10，如果请求中未传递则使用该默认值。
* @param movie_name 用于筛选已下架场次的电影名称。
* @return JSONObject 包含按电影名称分页查询已下架场次结果相关信息的 JSON 对象，包含 "code"、"count"、"data"、"income" 等字段传递相应数据。
*/
@RequestMapping("findOffScheduleByMovieName")
@ResponseBody
public JSONObject findOffScheduleByMovieName(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit,
@RequestParam("movie_name") String movie_name) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findOffScheduleByMovieName(page, limit, movie_name);
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for (int j = 0; j < info.getList().size(); j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for (int i = 0; i < orderList.size(); i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("income", incomeArr);
return obj;
}
/**
* 根据影院编号和电影编号查找场次信息的方法，处理按影院和电影关联查询场次的请求。
* 接收影院编号和电影编号作为参数，调用 scheduleService 的对应方法获取符合条件的场次列表，
* 将状态码、列表大小以及场次列表信息封装到 JSONObject 中返回。
*
* @param cinema_id 要查询场次对应的影院的唯一标识符。
* @param movie_id 要查询场次对应的电影的唯一标识符。
* @return JSONObject 包含按影院和电影关联查询场次结果相关信息的 JSON 对象，包含 "code"、"count"、"data" 等字段传递相应数据。
*/
@RequestMapping("findScheduleByCinemaAndMovie")
@ResponseBody
public JSONObject findScheduleByCinemaAndMovie(@RequestParam("cinema_id") long cinema_id,
@RequestParam("movie_id") long movie_id) {
JSONObject obj = new JSONObject();
List<Schedule> list = scheduleService.findScheduleByCineamIdAndMovieId(cinema_id, movie_id);
obj.put("code", 0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
/**
* 添加场次信息的方法，处理添加新场次的请求。
* 接收电影名称、放映厅名称、影院名称、场次价格以及场次开始时间等参数，通过调用相关服务层方法获取对应的电影、放映厅等对象信息，
* 设置场次对象的各项属性（如电影编号、放映厅编号、价格、开始时间、剩余座位数等），然后调用 scheduleService 的添加方法将场次信息保存到数据库中。
* 根据保存结果，在 JSONObject 中设置不同的状态码和提示消息后返回。
*
* @param movie_name 要添加场次对应的电影名称。
* @param hall_name 要添加场次对应的放映厅名称。
* @param cinema_name 要添加场次对应的影院名称。
* @param schedule_price 要添加场次的售价。
* @param schedule_startTime 要添加场次的开始时间，格式需符合业务要求。
* @return JSONObject 包含场次添加结果相关信息的 JSON 对象，包含 "code"（状态码）和 "mgs"（提示消息）字段传递相应数据。
*/
@RequestMapping("addSchedule")
@ResponseBody
public JSONObject addSchedule(@RequestParam("movie_name") String movie_name,
@RequestParam("hall_name") String hall_name,
@RequestParam("cinema_name") String cinema_name,
@RequestParam("schedule_price") int schedule_price,
@RequestParam("schedule_startTime") String schedule_startTime) {
JSONObject obj = new JSONObject();
Schedule schedule = new Schedule();
Hall hall = this.hallService.findHallByCinemaAndHallName(cinema_name, hall_name);
schedule.setMovie_id(this.movieService.findMovieByName(movie_name).getMovie_id());
schedule.setHall_id(hall.getHall_id());
schedule.setSchedule_price(schedule_price);
schedule.setSchedule_startTime(schedule_startTime);
schedule.setSchedule_remain(hall.getHall_capacity());
Integer rs = this.scheduleService.addSchedule(schedule);
if (rs > 0) {
obj.put("code", 0);
obj.put("mgs", "增加成功~");
} else {
obj.put("code", 200);
obj.put("mgs", "增加失败~");
}
return obj;
}
/**
* 修改场次价格的方法，处理修改指定场次价格的请求。
* 接收场次编号和新的场次价格作为参数，创建场次对象并设置其编号和新价格属性，
* 调用 scheduleService 的更新方法对场次价格进行修改，根据修改结果在 JSONObject 中设置不同的状态码和提示消息后返回。
*
* @param schedule_id 要修改价格的场次的唯一标识符。
* @param schedule_price 要修改后的场次价格。
* @return JSONObject 包含场次价格修改结果相关信息的 JSON 对象，包含 "code"（状态码）和 "mgs"（提示消息）字段传递相应数据。
*/
@RequestMapping("updateSchedulePrice")
@ResponseBody
public JSONObject updateSchedulePrice(@RequestParam("schedule_id") long schedule_id,
@RequestParam("schedule_price") int schedule_price) {
JSONObject obj = new JSONObject();
Schedule schedule = new Schedule();
schedule.setSchedule_id(schedule_id);
schedule.setSchedule_price(schedule_price);
Integer rs = this.scheduleService.updateSchedule(schedule);
if (rs > 0) {
obj.put("code", 0);
obj.put("mgs", "修改成功~");
} else {
obj.put("code", 200);
obj.put("mgs", "修改失败~");
}
return obj;
}
@Resource
private IScheduleService scheduleService;
@Resource
private IMovieService movieService;
@Resource
private ICinemaService cinemaService;
@Resource
private IHallService hallService;
@RequestMapping("findScheduleById")
@ResponseBody
public JSONObject findScheduleById(@RequestParam("schedule_id")long schedule_id) {
JSONObject obj = new JSONObject();
Schedule schedule = scheduleService.findScheduleById(schedule_id);
obj.put("code", 0);
obj.put("data",schedule);
return obj;
}
@RequestMapping("findAllScheduleByState")
@ResponseBody
public JSONObject findAllScheduleByState(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,@RequestParam("schedule_state")int schedule_state) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findAllScheduleByState(page, limit, schedule_state);
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for(int j = 0;j < info.getList().size();j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for(int i = 0;i < orderList.size();i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("income", incomeArr);
return obj;
}
@RequestMapping("findAllSchedule")
@ResponseBody
public JSONObject findAllSchedule(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findAllSchedule(page, limit);
List<Movie> movieList = movieService.findAllMovies(1);
List<Cinema> cinemaList = cinemaService.findAllCinemas();
ArrayList<String> movieArr = new ArrayList<String>();
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for(int j = 0;j < info.getList().size();j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for(int i = 0;i < orderList.size();i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
for(int i = 0;i < movieList.size();i++) {
movieArr.add(movieList.get(i).getMovie_cn_name());
}
ArrayList<Object> cinema = new ArrayList<>();
for(int i = 0;i < cinemaList.size();i++) {
JSONObject cinemaObj = new JSONObject();
List<Hall> hallList = hallService.findHallByCinemaId(cinemaList.get(i).getCinema_id());
ArrayList<String> hallArr = new ArrayList<String>();
for(int j = 0;j < hallList.size();j++) {
hallArr.add(hallList.get(j).getHall_name());
}
cinemaObj.put(cinemaList.get(i).getCinema_name(), hallList);
cinema.add(cinemaObj);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("movieName", movieArr);
obj.put("cinema", cinema);
obj.put("income", incomeArr);
return obj;
}
@RequestMapping("findScheduleByMovieName")
@ResponseBody
public JSONObject findScheduleByMovieName(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,@RequestParam("movie_name")String movie_name) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findScheduleByMovieName(page,limit,movie_name);
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for(int j = 0;j < info.getList().size();j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for(int i = 0;i < orderList.size();i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("income", incomeArr);
return obj;
}
@RequestMapping("findOffScheduleByMovieName")
@ResponseBody
public JSONObject findOffScheduleByMovieName(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,@RequestParam("movie_name")String movie_name) {
JSONObject obj = new JSONObject();
PageInfo<Schedule> info = scheduleService.findOffScheduleByMovieName(page, limit, movie_name);
ArrayList<Integer> incomeArr = new ArrayList<Integer>();
for(int j = 0;j < info.getList().size();j++) {
List<Order> orderList = info.getList().get(j).getOrderList();
int income = 0;
for(int i = 0;i < orderList.size();i++) {
income += orderList.get(i).getOrder_price();
}
incomeArr.add(income);
}
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
obj.put("income", incomeArr);
return obj;
}
@RequestMapping("findScheduleByCinemaAndMovie")
@ResponseBody
public JSONObject findScheduleByCinemaAndMovie(@RequestParam("cinema_id")long cinema_id,@RequestParam("movie_id")long movie_id) {
JSONObject obj = new JSONObject();
List<Schedule> list = scheduleService.findScheduleByCineamIdAndMovieId(cinema_id, movie_id);
obj.put("code",0);
obj.put("count",list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("addSchedule")
@ResponseBody
public JSONObject addSchedule(@RequestParam("movie_name")String movie_name,@RequestParam("hall_name")String hall_name,@RequestParam("cinema_name")String cinema_name,
@RequestParam("schedule_price")int schedule_price,@RequestParam("schedule_startTime")String schedule_startTime) {
JSONObject obj = new JSONObject();
Schedule schedule = new Schedule();
Hall hall = this.hallService.findHallByCinemaAndHallName(cinema_name, hall_name);
schedule.setMovie_id(this.movieService.findMovieByName(movie_name).getMovie_id());
schedule.setHall_id(hall.getHall_id());
schedule.setSchedule_price(schedule_price);
schedule.setSchedule_startTime(schedule_startTime);
schedule.setSchedule_remain(hall.getHall_capacity());
Integer rs = this.scheduleService.addSchedule(schedule);
if(rs > 0) {
obj.put("code", 0);
obj.put("mgs", "增加成功~");
}else {
obj.put("code", 200);
obj.put("mgs", "增加失败~");
}
return obj;
}
@RequestMapping("updateSchedulePrice")
@ResponseBody
public JSONObject updateSchedulePrice(@RequestParam("schedule_id")long schedule_id,@RequestParam("schedule_price")int schedule_price) {
JSONObject obj = new JSONObject();
Schedule schedule = new Schedule();
schedule.setSchedule_id(schedule_id);
schedule.setSchedule_price(schedule_price);
Integer rs = this.scheduleService.updateSchedule(schedule);
if(rs > 0) {
obj.put("code", 0);
obj.put("mgs", "修改成功~");
}else {
obj.put("code", 200);
obj.put("mgs", "修改失败~");
}
return obj;
}
@RequestMapping("offlineSchedule")
@ResponseBody
public JSONObject offlineSchedule(@RequestParam("schedule_id")long schedule_id) {
JSONObject obj = new JSONObject();
Integer rs = this.scheduleService.deleteSchedule(schedule_id);
if(rs > 0) {
obj.put("code", 0);
obj.put("mgs", "下架成功~");
}else {
obj.put("code", 200);
obj.put("mgs", "下架失败~");
}
return obj;
}
/**
* 测试类Api 根据电影id找到所有放映该电影的影院列表
* @param movie_id
* @return
*/
@RequestMapping("findCinemasByMovieId")
@ResponseBody
public JSONObject findCinemasByMovieId(@RequestParam("movie_id")long movie_id) {
JSONObject obj = new JSONObject();
List<Cinema> list = this.cinemaService.findCinemasByMovieId(movie_id);
obj.put("code", 0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
/**
* 测试专用api
*/
@RequestMapping("testHall")
@ResponseBody
public JSONObject testHall(@RequestParam("hall_name")String hall_name,@RequestParam("cinema_name")String cinema_name) {
Hall hall = this.hallService.findHallByCinemaAndHallName(cinema_name, hall_name);
JSONObject obj = new JSONObject();
obj.put("data", hall);
return obj;
}
}

442
src/main/java/com/controller/UserController.java
Unescape View File

@ -24,273 +24,189 @@ import com.entity.User;
import com.github.pagehelper.PageInfo;
import com.service.IUserService;
import com.util.UUIDUtil;
/**
* 用户管理模块，主要负责处理与用户相关的各种业务请求，例如用户登录、注册、信息修改、密码修改、查询用户列表等功能。
* 用户管理模块
* update: 2019年7月9日17:18:50
* @author Wxj
*/
@Controller
@RequestMapping("/user")
// 该类使用Spring的 @Controller 注解标记，表示这是一个控制器类，用于处理Web请求。
// @RequestMapping("/user") 则定义了该控制器处理的请求路径的基础部分，后续具体方法的请求路径在此基础上扩展。
public class UserController {
// 原本使用 @Autowired 进行依赖注入，后改为使用 @Resource，用于将 IUserService 的实现类注入到当前控制器中，
// 以便调用用户服务层提供的各种业务方法来处理用户相关操作。
// @Autowired
@Resource
private IUserService userService;
/**
* 用户登录方法，处理用户登录请求。
* 接收用户名和密码以及 HttpServletRequest 对象，通过调用 userService 的登录方法验证用户信息。
* 如果验证通过，将用户信息存入会话（Session）中，并根据用户角色返回不同的成功提示信息及用户数据；若验证失败则返回失败提示信息。
* @param user_name 用户名，用于登录验证。
* @param user_pwd 用户密码，用于登录验证。
* @param request HttpServletRequest 对象，用于获取会话等操作。
* @return JSONObject 包含登录结果相关信息（如提示消息、用户数据等）的 JSON 对象。
*/
@RequestMapping("login")
@ResponseBody
public JSONObject login(String user_name, String user_pwd, HttpServletRequest request) {
JSONObject obj = new JSONObject();
User user = userService.login(user_name, user_pwd);
if (user!= null) {
HttpSession session = request.getSession();
session.setAttribute("user", user);
if (user.getUser_role() == 0) {
obj.put("msg", "usersuccess");
obj.put("data", user);
return obj;
} else {
obj.put("msg", "adminsuccess");
obj.put("data", user);
return obj;
}
}
obj.put("msg", "fail");
return obj;
}
/**
* 用户注销方法，处理用户注销请求。
* 通过获取 HttpServletRequest 中的会话对象，移除其中存储的用户信息，实现用户注销功能，然后返回 "index"，可能用于页面跳转等后续操作。
* @param request HttpServletRequest 对象，用于获取会话。
* @return String 返回 "index"，可能对应着页面跳转的标识或者其他相关逻辑。
*/
@RequestMapping("logout")
@ResponseBody
public String logout(HttpServletRequest request) {
HttpSession session = request.getSession();
session.removeAttribute("user");
return "index";
}
/**
* 用户注册方法，处理用户注册请求。
* 接收一个 User 对象，先根据用户名查询是否已存在同名用户，如果存在则返回 "fail" 表示注册失败；
* 若不存在同名用户，则调用 userService 的添加用户方法进行注册，注册成功返回 "success"，失败返回 "fail"。
* @param user 包含用户注册信息的 User 对象。
* @return String 注册结果，"success" 表示成功，"fail" 表示失败。
*/
@RequestMapping("register")
@ResponseBody
public String register(User user) {
List<User> list = userService.findUserByName(user.getUser_name());
if (list.size() > 0) {
return "fail";
} else {
Integer rs = userService.addUser(user);
if (rs > 0) {
return "success";
} else {
return "fail";
}
}
}
/**
* 更新用户信息方法，处理用户信息更新请求。
* 接收一个包含更新后用户信息的 User 对象，调用 userService 的更新用户信息方法进行更新操作，
* 根据更新结果返回 "success"（更新成功）或 "fail"（更新失败）。
* @param user 包含更新后用户信息的 User 对象。
* @return String 更新结果，"success" 表示成功，"fail" 表示失败。
*/
@RequestMapping("updateUser")
@ResponseBody
public String updateUser(User user) {
Integer rs = userService.updateUserInfo(user);
if (rs > 0) {
return "success";
} else {
return "fail";
}
}
/**
* 修改用户密码方法，处理用户密码修改请求。
* 接收旧密码和新密码以及 HttpServletRequest 对象，从会话中获取当前登录用户信息，验证旧密码是否正确，
* 如果正确则更新用户密码，移除会话中的用户信息（可能是重新登录等后续逻辑需要），然后返回 "success"；若旧密码验证失败则返回 "fail"。
* @param oldPwd 旧密码，用于验证。
* @param newPwd 新密码，用于更新用户密码。
* @param request HttpServletRequest 对象，用于获取会话中的用户信息。
* @return String 修改密码结果，"success" 表示成功，"fail" 表示失败。
*/
@RequestMapping("modifyUserPwd")
@ResponseBody
public String modifyUserPwd(@RequestParam("oldPwd") String oldPwd, @RequestParam("newPwd") String newPwd,
HttpServletRequest request) {
HttpSession session = request.getSession();
User user = (User) session.getAttribute("user");
if (user.getUser_pwd().equals(oldPwd)) {
user.setUser_pwd(newPwd);
userService.updateUserInfo(user);
session.removeAttribute("user");
return "success";
} else {
return "fail";
}
}
/**
* 分页查询所有用户方法，处理查询所有用户的请求，并支持分页和关键字搜索功能。
* 接收页码、每页显示数量以及关键字等参数，通过调用 userService 的分页查询方法获取用户信息，
* 将查询结果封装到 JSONObject 中，包含提示消息、状态码、总记录数以及用户数据列表等信息后返回。
* @param page 当前页码，默认值为1，如果请求中未传递则使用该默认值。
* @param limit 每页显示的用户数量，默认值为10，如果请求中未传递则使用该默认值。
* @param keyword 用于搜索用户的关键字，可为空。
* @return JSONObject 包含用户列表查询结果相关信息的 JSON 对象。
*/
@RequestMapping("findAllUser")
@ResponseBody
public JSONObject findAllUser(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit,
String keyword) {
PageInfo<User> info = userService.findAllUserBySplitPage(page, limit, keyword);
JSONObject obj = new JSONObject();
obj.put("msg", "");
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
/**
* 查询所有用户信息方法，处理查询所有用户信息的请求，不涉及分页功能。
* 获取所有用户信息列表，将查询结果封装到 JSONObject 中，包含提示消息、状态码、总记录数以及用户数据列表等信息后返回。
* @return JSONObject 包含用户列表查询结果相关信息的 JSON 对象。
*/
@RequestMapping("findAllUserInfos")
@ResponseBody
public JSONObject findAllUserInfos() {
JSONObject obj = new JSONObject();
List<User> list = userService.findAllUserInfos();
obj.put("msg", "");
obj.put("code", 0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
/**
* 根据用户名模糊查询用户信息方法，处理根据用户名模糊查询用户信息的请求。
* 接收用户名参数，通过调用 userService 的模糊查询方法获取匹配的用户信息列表，
* 将查询结果封装到 JSONObject 中，包含提示消息、状态码、总记录数以及用户数据列表等信息后返回。
* @param user_name 用于模糊查询用户的用户名。
* @return JSONObject 包含用户列表查询结果相关信息的 JSON 对象。
*/
@RequestMapping("findUserInfosByName")
@ResponseBody
public JSONObject findUserInfosByName(@RequestParam("user_name") String user_name) {
JSONObject obj = new JSONObject();
List<User> list = userService.findUserLikeName(user_name);
obj.put("msg", "");
obj.put("code", 0);
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
/**
* 用户头像上传方法，处理用户头像上传请求，同时也可用于更新用户的其他信息。
* 接收上传的文件（头像图片）、用户信息以及 HttpServletRequest 对象。
* 如果文件不为空，则生成唯一文件名，确定文件保存路径并将文件保存到服务器指定位置，同时更新用户头像路径信息；
* 如果文件为空，则使用数据库中已有的用户头像路径及密码等信息。最后调用 userService 的更新用户信息方法更新用户信息，
* 根据更新结果封装不同的提示信息及用户数据到 JSONObject 中返回。
* @param file 上传的头像文件，可为空。
* @param user 包含用户相关信息的 User 对象，用于更新头像路径等信息以及传递给服务层更新用户其他数据。
* @param request HttpServletRequest 对象，用于获取服务器上下文路径等信息来确定文件保存位置。
* @return JSONObject 包含头像上传及用户信息更新结果相关信息的 JSON 对象。
* @throws IOException 如果文件保存过程中出现 I/O 异常则抛出。
*/
@RequestMapping("/uploadHeadImg")
@ResponseBody
public JSONObject uploadHeadImg(@RequestParam(value = "file", required = false) MultipartFile file, User user,
HttpServletRequest request) throws IOException {
JSONObject obj = new JSONObject();
if (file!= null) {
String str = file.getOriginalFilename();
System.out.println("file:" + str);
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:" + name);
String path = request.getServletContext().getRealPath("/upload/head") + "/" + name;
System.out.println("path:" + path);
String filePath = "../upload/head/" + name;
user.setUser_headImg(filePath);
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
} else {
user.setUser_headImg(this.userService.findUserById(user.getUser_id()).getUser_headImg());
user.setUser_pwd(this.userService.findUserById(user.getUser_id()).getUser_pwd());
}
Integer rs = userService.updateUserInfo(user);
if (rs > 0) {
obj.put("code", 0);
obj.put("msg", "");
obj.put("data", user);
} else {
obj.put("code", 200);
obj.put("msg", "");
}
return obj;
}
/**
* 测试 API 方法，主要用于测试文件上传相关功能（可能是开发过程中的临时测试方法）。
* 接收上传的文件、用户名以及 HttpServletRequest 对象，打印文件相关信息，
* 如果文件不为空，则进行文件保存操作并将文件名等信息封装到 JSONObject 中返回；若文件为空则打印相应提示信息。
* @param file 上传的文件，可为空。
* @param user_name 用户名，目前在方法中的具体用途不太明确，可能是测试相关逻辑需要。
* @param request HttpServletRequest 对象，用于获取服务器上下文路径等信息来确定文件保存位置。
* @return JSONObject 包含文件相关信息（如文件名等）的 JSON 对象，若文件为空则返回相应简单封装的对象。
*/
@RequestMapping("test")
@ResponseBody
public JSONObject uploadImg(@RequestParam(value = "file", required = false) MultipartFile file,
@RequestParam("user_name") String user_name, HttpServletRequest request) {
System.out.println(file);
JSONObject obj = new JSONObject();
if (file == null) {
System.out.println("null");
} else {
String str = file.getOriginalFilename();
System.out.println("file:" + str);
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:" + name);
String path = request.getServletContext().getRealPath("/upload/head") + "/" + name;
System.out.println("path:" + path);
String filePath = "upload/head/" + name;
System.out.println(filePath);
try {
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
} catch (IOException ex) {
ex.printStackTrace();
}
obj.put("file", name);
obj.put("user_name", user_name);
}
return obj;
}
}
//@Autowired
@Resource
private IUserService userService;
@RequestMapping("login")
@ResponseBody
public JSONObject login(String user_name,String user_pwd,HttpServletRequest request) {
JSONObject obj = new JSONObject();
User user = userService.login(user_name, user_pwd);
if(user != null) {
HttpSession session = request.getSession();
session.setAttribute("user", user);
if(user.getUser_role() == 0) {
obj.put("msg", "usersuccess");
obj.put("data", user);
return obj;
}else {
obj.put("msg", "adminsuccess");
obj.put("data", user);
return obj;
}
}
obj.put("msg", "fail");
return obj;
}
@RequestMapping("logout")
@ResponseBody
public String logout(HttpServletRequest request) {
HttpSession session = request.getSession();
session.removeAttribute("user");
return "index";
}
@RequestMapping("register")
@ResponseBody
public String register(User user) {
List<User> list = userService.findUserByName(user.getUser_name());
if(list.size() > 0) {
return "fail";
}else {
Integer rs = userService.addUser(user);
if(rs > 0) {
return "success";
}else {
return "fail";
}
}
}
@RequestMapping("updateUser")
@ResponseBody
public String updateUser(User user) {
Integer rs = userService.updateUserInfo(user);
if(rs > 0) {
return "success";
}else {
return "fail";
}
}
@RequestMapping("modifyUserPwd")
@ResponseBody
public String modifyUserPwd(@RequestParam("oldPwd")String oldPwd,@RequestParam("newPwd")String newPwd,HttpServletRequest request) {
HttpSession session = request.getSession();
User user = (User)session.getAttribute("user");
if(user.getUser_pwd().equals(oldPwd)) {
user.setUser_pwd(newPwd);
userService.updateUserInfo(user);
session.removeAttribute("user");
return "success";
}else {
return "fail";
}
}
@RequestMapping("findAllUser")
@ResponseBody
public JSONObject findAllUser(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,String keyword) {
PageInfo<User> info = userService.findAllUserBySplitPage(page, limit, keyword);
JSONObject obj = new JSONObject();
obj.put("msg", "");
obj.put("code", 0);
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
@RequestMapping("findAllUserInfos")
@ResponseBody
public JSONObject findAllUserInfos() {
JSONObject obj = new JSONObject();
List<User> list = userService.findAllUserInfos();
obj.put("msg","");
obj.put("code",0);
obj.put("count",list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("findUserInfosByName")
@ResponseBody
public JSONObject findUserInfosByName(@RequestParam("user_name")String user_name) {
JSONObject obj = new JSONObject();
List<User> list = userService.findUserLikeName(user_name);
obj.put("msg","");
obj.put("code",0);
obj.put("count",list.size());
obj.put("data", list);
return obj;
}
@RequestMapping("/uploadHeadImg")
@ResponseBody
public JSONObject uploadHeadImg(@RequestParam(value="file",required=false) MultipartFile file,User user,HttpServletRequest request) throws IOException {
JSONObject obj = new JSONObject();
if(file != null) {
String str = file.getOriginalFilename();
System.out.println("file:"+str);
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:"+name);
String path = request.getServletContext().getRealPath("/upload/head") + "/" + name;
System.out.println("path:"+path);
String filePath = "../upload/head/" + name;
user.setUser_headImg(filePath);
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
}else {
user.setUser_headImg(this.userService.findUserById(user.getUser_id()).getUser_headImg());
user.setUser_pwd(this.userService.findUserById(user.getUser_id()).getUser_pwd());
}
Integer rs = userService.updateUserInfo(user);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "");
obj.put("data",user);
}else {
obj.put("code", 200);
obj.put("msg", "");
}
return obj;
}
/**
* 测试Api
* @param file
* @param user_name
* @param request
* @return
*/
@RequestMapping("test")
@ResponseBody
public JSONObject uploadImg(@RequestParam(value="file",required=false) MultipartFile file,@RequestParam("user_name")String user_name,HttpServletRequest request) {
System.out.println(file);
JSONObject obj = new JSONObject();
if(file == null) {
System.out.println("null");
}else {
String str = file.getOriginalFilename();
System.out.println("file:"+str);
String name = UUIDUtil.getUUID() + str.substring(str.lastIndexOf("."));
System.out.println("name:"+name);
String path = request.getServletContext().getRealPath("/upload/head") + "/" + name;
System.out.println("path:"+path);
String filePath = "upload/head/" + name;
System.out.println(filePath);
try {
file.transferTo(new File(path));
System.out.println("文件写入成功,Path:" + path);
}catch(IOException ex) {
ex.printStackTrace();
}
obj.put("file", name);
obj.put("user_name",user_name);
}
return obj;
}
}

282
src/main/java/com/entity/Movie.java
Unescape View File

@ -1,173 +1,125 @@
package com.entity;
import java.sql.Date; // 导入 java.sql.Date 类，用于表示日期，格式通常为 yyyy-mm-dd，这里用于存储电影的相关日期信息
import java.sql.Date; //yyyy-mm-dd
import java.util.List;
/**
* 电影信息实体对象
* 该类用于封装电影相关的各种属性信息，作为数据传输和业务逻辑处理中代表电影的实体存在。
* @author Wxj
*/
public class Movie {
// 电影的唯一标识符，通常是数据库中的主键，用于唯一确定一部电影
private long movie_id;
// 电影的中文名称，用于展示给用户或者在中文语境下进行相关操作时使用
private String movie_cn_name;
// 电影的外文名称（从变量名推测，可能是拼音或者其他外语名称等），用于多语言相关场景或者对外交流展示等情况
private String movie_fg_name;
// 电影的演职人员信息，可能包含主演、配角等人员的姓名列表等相关内容，以字符串形式存储（更合理的方式也可以是用特定对象集合来表示）
private String movie_actor; // 演职人员
// 电影的导演信息，存储导演的姓名，若有多个导演可能以特定格式拼接在这个字符串中（同样也可考虑用更合适的对象集合等方式存储）
private String movie_director; // 导演
// 电影的详细介绍内容，比如剧情梗概、影片特色等详细文字描述，用于用户查看电影详情时展示
private String movie_detail; // 电影详情
// 电影的时长信息，通常格式可能是"XX分钟"之类的字符串形式，用于告知用户影片播放时长
private String movie_duration; // 电影时长
// 电影的类型信息，例如"喜剧"、"动作"、"科幻"等分类，以字符串形式存储（也可考虑用枚举等更规范的方式表示类型），方便按类型筛选、展示电影
private String movie_type; // 电影类型
// 电影的评分信息，以浮点数形式存储，一般是根据用户评价等综合计算得出的平均分数，用于衡量电影质量和受欢迎程度
private float movie_score; // 电影评分
// 电影的票房数据，以浮点数形式存储，代表电影取得的票房收入情况，用于统计分析电影商业表现等
private float movie_boxOffice; // 票房
// 电影的参评人数，即参与对该电影评分、评价等操作的用户数量，以长整型存储，可用于参考评分的可信度等情况
private long movie_commentCount; // 电影参评人数
// 电影的上映时间，使用 java.sql.Date 类型存储，能准确表示具体的年月日信息，便于查询、筛选不同时间段上映的电影
private Date movie_releaseDate; // 上映时间
// 电影的制片地区信息，比如"中国"、"美国"等，以字符串形式存储，有助于按地区分类、推荐电影等操作
private String movie_country; // 制片地区
// 电影海报的地址信息，存储海报图片在服务器或者网络中的位置，用于前端页面展示电影海报时获取图片资源
private String movie_picture; // 电影海报地址
// 电影的状态信息，用整数表示，默认值为 1，1 代表电影处于在线状态（可正常观看、展示等），0 代表电影已下架（不可见或者无法观看等情况）
private int movie_state; // 电影状态 默认 1 1：在线 0：下架
// 存储该电影所有的评论信息，以 Comment 类型的列表形式存在，方便获取、管理和展示用户对这部电影的各种评论内容
private List<Comment> commentList; // 所有的评论信息
// 获取电影的唯一标识符 movie_id 的方法，供外部类访问该私有属性
public long getMovie_id() {
return movie_id;
}
// 设置电影的唯一标识符 movie_id 的方法，外部类可以通过该方法给 movie_id 属性赋值
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
// 获取电影的中文名称 movie_cn_name 的方法，用于外部获取该属性值展示或者使用
public String getMovie_cn_name() {
return movie_cn_name;
}
// 获取电影的状态 movie_state 的方法，外部可通过此方法得知电影当前处于在线还是下架等状态
public int getMovie_state() {
return movie_state;
}
// 设置电影的状态 movie_state 的方法，外部可通过此方法改变电影的状态（比如管理员操作下架电影等情况）
public void setMovie_state(int movie_state) {
this.movie_state = movie_state;
}
// 设置电影的中文名称 movie_cn_name 的方法，外部类可调用此方法来更新电影的中文名称
public void setMovie_cn_name(String movie_cn_name) {
this.movie_cn_name = movie_cn_name;
}
// 获取电影的外文名称 movie_fg_name 的方法，供外部类在需要时获取该属性值
public String getMovie_fg_name() {
return movie_fg_name;
}
// 设置电影的外文名称 movie_fg_name 的方法，外部可通过调用此方法来修改电影的外文名称
public void setMovie_fg_name(String movie_fg_name) {
this.movie_fg_name = movie_fg_name;
}
// 获取电影的演职人员信息 movie_actor 的方法，用于外部展示或者处理相关人员信息
public String getMovie_actor() {
return movie_actor;
}
// 设置电影的演职人员信息 movie_actor 的方法，外部可调用此方法更新演职人员相关内容（比如新增演员等情况）
public void setMovie_actor(String movie_actor) {
this.movie_actor = movie_actor;
}
// 获取电影的导演信息 movie_director 的方法，方便外部获取并展示导演相关信息
public String getMovie_director() {
return movie_director;
}
// 设置电影的导演信息 movie_director 的方法，外部可通过此方法改变电影的导演信息（比如有误录入需要修改等情况）
public void setMovie_director(String movie_director) {
this.movie_director = movie_director;
}
// 获取电影的详细介绍内容 movie_detail 的方法，用于在前端页面等地方展示电影的详细情况给用户查看
public String getMovie_detail() {
return movie_detail;
}
// 设置电影的详细介绍内容 movie_detail 的方法，外部可通过调用此方法更新电影的详细介绍信息（比如补充更详细的剧情等情况）
public void setMovie_detail(String movie_detail) {
this.movie_detail = movie_detail;
}
// 获取电影的时长信息 movie_duration 的方法，外部可通过此方法获取并展示给用户影片播放时长情况
public String getMovie_duration() {
return movie_duration;
}
// 设置电影的时长信息 movie_duration 的方法，外部可调用此方法更新电影时长信息（比如纠正错误时长等情况）
public void setMovie_duration(String movie_duration) {
this.movie_duration = movie_duration;
}
// 获取电影的类型信息 movie_type 的方法，方便外部按类型进行分类、筛选、展示电影等操作
public String getMovie_type() {
return movie_type;
}
// 设置电影的类型信息 movie_type 的方法，外部可通过此方法修改电影的类型分类（比如重新归类等情况）
public void setMovie_type(String movie_type) {
this.movie_type = movie_type;
}
// 获取电影的评分信息 movie_score 的方法，外部可通过此方法获取并展示电影的评分情况给用户参考
public float getMovie_score() {
return movie_score;
}
// 设置电影的评分信息 movie_score 的方法，一般来说评分是根据一定算法计算得出后通过此方法更新，而不是随意设置（实际应用中可能会有限制逻辑等）
public void setMovie_score(float movie_score) {
this.movie_score = movie_score;
}
// 获取电影的票房数据 movie_boxOffice 的方法，用于外部统计、展示电影的商业票房表现情况
public float getMovie_boxOffice() {
return movie_boxOffice;
}
// 设置电影的票房数据 movie_boxOffice 的方法，通常是在票房数据更新时（比如新的票房统计结果出来后）调用此方法进行设置
public void setMovie_boxOffice(float movie_boxOffice) {
this.movie_boxOffice = movie_boxOffice;
}
// 获取电影的参评人数 movie_commentCount 的方法，外部可通过此方法获取参与评价的用户数量情况，用于参考评分可信度等
public long getMovie_commentCount() {
return movie_commentCount;
}
// 设置电影的参评人数 movie_commentCount 的方法，在参评人数有变化（比如新用户参与评价等情况）时可调用此方法更新
public void setMovie_commentCount(long movie_commentCount) {
this.movie_commentCount = movie_commentCount;
}
// 获取电影的上映时间 movie_releaseDate 的方法，方便外部按上映时间查询、筛选电影等操作
public Date getReleaseDate() {
return movie_releaseDate;
}
// 设置电影的上映时间 movie_releaseDate 的方法，一般在录入电影信息或者修改上映时间等情况时调用此方法（不过实际应用中上映时间通常是确定后较少修改的）
public void setReleaseDate(Date releaseDate) {
this.movie_releaseDate = releaseDate;
}
// 获取电影的制片地区信息 movie_country 的方法，外部可通过此方法获取并按地区分类、展示电影等
public String getMovie_country() {
return movie_country;
}
// 设置电影的制片地区信息 movie_country 的方法，在发现地区信息录入错误等情况时可调用此方法进行修改
public void setMovie_country(String movie_country) {
this.movie_country = movie_country;
}
// 获取电影海报地址信息 movie_picture 的方法，用于前端页面等获取海报图片资源展示电影海报
public String getMovie_picture() {
return movie_picture;
}
// 设置电影海报地址信息 movie_picture 的方法，比如海报更换后可通过此方法更新地址信息
public void setMovie_picture(String movie_picture) {
this.movie_picture = movie_picture;
}
// 获取该电影所有评论信息的列表 commentList 的方法，外部可通过此方法获取并展示、处理用户的评论内容
public List<Comment> getCommentList() {
return commentList;
}
// 设置该电影所有评论信息的列表 commentList 的方法，一般在添加新评论、删除评论等操作后调用此方法更新评论列表（实际应用中可能会有更复杂的逻辑配合）
public void setCommentList(List<Comment> commentList) {
this.commentList = commentList;
}
}
private long movie_id;
private String movie_cn_name;
private String movie_fg_name;
private String movie_actor; //演职人员
private String movie_director; //导演
private String movie_detail; //电影详情
private String movie_duration; //电影时长
private String movie_type; //电影类型
private float movie_score; //电影评分
private float movie_boxOffice; //票房
private long movie_commentCount; //电影参评人数
private Date movie_releaseDate; //上映时间
private String movie_country; //制片地区
private String movie_picture; //电影海报地址
private int movie_state; //电影状态 默认1 1：在线 0：下架
private List<Comment> commentList; //所有的评论信息
public long getMovie_id() {
return movie_id;
}
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
public String getMovie_cn_name() {
return movie_cn_name;
}
public int getMovie_state() {
return movie_state;
}
public void setMovie_state(int movie_state) {
this.movie_state = movie_state;
}
public void setMovie_cn_name(String movie_cn_name) {
this.movie_cn_name = movie_cn_name;
}
public String getMovie_fg_name() {
return movie_fg_name;
}
public void setMovie_fg_name(String movie_fg_name) {
this.movie_fg_name = movie_fg_name;
}
public String getMovie_actor() {
return movie_actor;
}
public void setMovie_actor(String movie_actor) {
this.movie_actor = movie_actor;
}
public String getMovie_director() {
return movie_director;
}
public void setMovie_director(String movie_director) {
this.movie_director = movie_director;
}
public String getMovie_detail() {
return movie_detail;
}
public void setMovie_detail(String movie_detail) {
this.movie_detail = movie_detail;
}
public String getMovie_duration() {
return movie_duration;
}
public void setMovie_duration(String movie_duration) {
this.movie_duration = movie_duration;
}
public String getMovie_type() {
return movie_type;
}
public void setMovie_type(String movie_type) {
this.movie_type = movie_type;
}
public float getMovie_score() {
return movie_score;
}
public void setMovie_score(float movie_score) {
this.movie_score = movie_score;
}
public float getMovie_boxOffice() {
return movie_boxOffice;
}
public void setMovie_boxOffice(float movie_boxOffice) {
this.movie_boxOffice = movie_boxOffice;
}
public long getMovie_commentCount() {
return movie_commentCount;
}
public void setMovie_commentCount(long movie_commentCount) {
this.movie_commentCount = movie_commentCount;
}
public Date getReleaseDate() {
return movie_releaseDate;
}
public void setReleaseDate(Date releaseDate) {
this.movie_releaseDate = releaseDate;
}
public String getMovie_country() {
return movie_country;
}
public void setMovie_country(String movie_country) {
this.movie_country = movie_country;
}
public String getMovie_picture() {
return movie_picture;
}
public void setMovie_picture(String movie_picture) {
this.movie_picture = movie_picture;
}
public List<Comment> getCommentList() {
return commentList;
}
public void setCommentList(List<Comment> commentList) {
this.commentList = commentList;
}
}

182
src/main/java/com/entity/Schedule.java
Unescape View File

@ -6,112 +6,82 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
/**
* 场次表实体对象，用于表示电影场次相关的信息，包含场次自身的编号、所属放映厅、放映电影编号、放映时间、售价、剩余座位数等属性，
* 以及关联的所属放映厅对象、放映的电影对象和该场次对应的所有订单集合等信息。
* 场次表实体对象
* @author Wxj
*/
public class Schedule {
// 场次的唯一标识符
private long schedule_id;
// 所属放映厅的编号，通过该编号可以关联到对应的放映厅信息，比如放映厅的位置、座位布局等情况。
private long hall_id;
// 放映的电影编号，用于确定具体放映的是哪一部电影，可通过该编号关联到电影的详细信息，如电影名称、类型等。
private long movie_id;
// 电影放映时间，这里目前是字符串类型存储，格式可能需要按照一定规则来解析，若要进行日期格式化操作，可启用下面被注释掉的注解配置。
// @DateTimeFormat(pattern="yyyy-MM-dd")
private String schedule_startTime;
// 该场次电影的售价，单位可能是具体业务规定的货币单位，比如元。
private int schedule_price;
// 该场次剩余的座位数量，用于判断是否还有足够座位可供售卖等业务逻辑。
private int schedule_remain;
// 场次状态，1表示上映中，0表示下架，通过该状态可以控制场次在业务系统中的展示和操作逻辑。
private int schedule_state;
// 所属放映厅对象，通过该对象可以更方便地获取放映厅的详细属性和执行相关操作，是与Hall类的关联对象。
private Hall schedule_hall;
// 放映的电影对象，用于获取电影更全面的详细信息，是与Movie类的关联对象。
private Movie schedule_movie;
// 所有的订单集合，包含购买该场次电影票的所有订单信息，可用于查询、统计等业务操作。
private List<Order> orderList;
// 获取场次的唯一标识符
public long getSchedule_id() {
return schedule_id;
}
// 设置场次的唯一标识符
public void setSchedule_id(long schedule_id) {
this.schedule_id = schedule_id;
}
// 获取场次状态
public int getSchedule_state() {
return schedule_state;
}
// 设置场次状态
public void setSchedule_state(int schedule_state) {
this.schedule_state = schedule_state;
}
// 获取放映的电影对象
public Movie getSchedule_movie() {
return schedule_movie;
}
// 设置放映的电影对象
public void setSchedule_movie(Movie schedule_movie) {
this.schedule_movie = schedule_movie;
}
// 获取所属放映厅的编号
public long getHall_id() {
return hall_id;
}
// 设置所属放映厅的编号
public void setHall_id(long hall_id) {
this.hall_id = hall_id;
}
// 获取放映的电影编号
public long getMovie_id() {
return movie_id;
}
// 设置放映的电影编号
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
// 获取电影放映时间
public String getSchedule_startTime() {
return schedule_startTime;
}
// 设置电影放映时间
public void setSchedule_startTime(String schedule_startTime) {
this.schedule_startTime = schedule_startTime;
}
// 获取该场次电影的售价
public int getSchedule_price() {
return schedule_price;
}
// 设置该场次电影的售价
public void setSchedule_price(int schedule_price) {
this.schedule_price = schedule_price;
}
// 获取该场次剩余的座位数量
public int getSchedule_remain() {
return schedule_remain;
}
// 设置该场次剩余的座位数量
public void setSchedule_remain(int schedule_remain) {
this.schedule_remain = schedule_remain;
}
// 获取所属放映厅对象
public Hall getSchedule_hall() {
return schedule_hall;
}
// 设置所属放映厅对象
public void setSchedule_hall(Hall schedule_hall) {
this.schedule_hall = schedule_hall;
}
// 获取所有的订单集合
public List<Order> getOrderList() {
return orderList;
}
// 设置所有的订单集合
public void setOrderList(List<Order> orderList) {
this.orderList = orderList;
}
}
private long schedule_id;
private long hall_id; //所属放映厅
private long movie_id; //放映的电影编号
//@DateTimeFormat(pattern="yyyy-MM-dd")
private String schedule_startTime; //电影放映时间
private int schedule_price; //售价
private int schedule_remain; //剩余座位数
private int schedule_state; //场次状态 1：上映中 0：下架
private Hall schedule_hall; //所属放映厅对象
private Movie schedule_movie; //放映的电影
private List<Order> orderList; //所有的订单集合
public long getSchedule_id() {
return schedule_id;
}
public void setSchedule_id(long schedule_id) {
this.schedule_id = schedule_id;
}
public int getSchedule_state() {
return schedule_state;
}
public void setSchedule_state(int schedule_state) {
this.schedule_state = schedule_state;
}
public Movie getSchedule_movie() {
return schedule_movie;
}
public void setSchedule_movie(Movie schedule_movie) {
this.schedule_movie = schedule_movie;
}
public long getHall_id() {
return hall_id;
}
public void setHall_id(long hall_id) {
this.hall_id = hall_id;
}
public long getMovie_id() {
return movie_id;
}
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
public String getSchedule_startTime() {
return schedule_startTime;
}
public void setSchedule_startTime(String schedule_startTime) {
this.schedule_startTime = schedule_startTime;
}
public int getSchedule_price() {
return schedule_price;
}
public void setSchedule_price(int schedule_price) {
this.schedule_price = schedule_price;
}
public int getSchedule_remain() {
return schedule_remain;
}
public void setSchedule_remain(int schedule_remain) {
this.schedule_remain = schedule_remain;
}
public Hall getSchedule_hall() {
return schedule_hall;
}
public void setSchedule_hall(Hall schedule_hall) {
this.schedule_hall = schedule_hall;
}
public List<Order> getOrderList() {
return orderList;
}
public void setOrderList(List<Order> orderList) {
this.orderList = orderList;
}
}

73
src/main/java/com/mapper/CinemaMapper.java
Unescape View File

@ -6,70 +6,13 @@ import org.springframework.stereotype.Repository;
import com.entity.Cinema;
/**
* CinemaMapper接口，用于定义对电影院相关数据进行持久化操作（通常对应数据库操作）的方法签名。
* 该接口一般会由对应的Mapper实现类来具体实现其方法逻辑，以实现与数据库的交互，例如查询、插入、更新和删除电影院信息等操作。
* 通过使用`@Repository`注解，将该接口标记为Spring的持久层组件，便于Spring框架进行管理和依赖注入等操作。
*/
@Repository
public interface CinemaMapper {
/**
* 根据电影院的唯一标识（ID）查询电影院信息的方法签名。
* 对应的实现类中应该编写具体的SQL语句（例如使用MyBatis框架时在对应的XML映射文件中编写SQL）来从数据库中查找指定ID的电影院记录，并将其映射为`Cinema`实体对象返回。
* @param cinema_id 要查询的电影院的ID
* @return 返回一个`Cinema`对象，代表查询到的电影院信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Cinema findCinemaById(long cinema_id);
/**
* 向数据库中插入一条新的电影院记录的方法签名。
* 实现类中需要编写合适的SQL插入语句，将传入的`Cinema`对象所包含的电影院信息插入到数据库对应的表中，
* 并根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定）。
* @param cinema 包含要插入的电影院信息的`Cinema`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addCinema(Cinema cinema);
/**
* 根据传入的`Cinema`对象信息更新数据库中对应的电影院记录的方法签名。
* 实现类中要编写相应的SQL更新语句，依据`Cinema`对象中的属性值来更新数据库里对应电影院记录的相应字段，
* 同样根据更新操作结果返回受影响的行数，用于判断更新是否成功执行。
* @param cinema 包含更新后电影院信息的`Cinema`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateCinema(Cinema cinema);
/**
* 根据电影院的唯一标识（ID）从数据库中删除对应的电影院记录的方法签名。
* 实现类需编写SQL删除语句，将指定ID的电影院记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况）。
* @param cinema_id 要删除的电影院的ID
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
Integer deleteCinema(long cinema_id);
/**
* 查询数据库中所有电影院信息的方法签名。
* 对应的实现类应编写SQL查询语句，从数据库表中获取全部的电影院记录，并将每条记录映射为`Cinema`实体对象，最后以`List<Cinema>`集合的形式返回所有电影院信息列表。
* @return 返回一个包含所有`Cinema`对象的`List`集合，每个对象代表一条电影院记录信息
*/
List<Cinema> findAllCinemas();
/**
* 根据电影院名称进行模糊查询的方法签名。
* 实现类中的SQL语句会按照传入的电影院名称（支持模糊匹配的方式，例如包含部分名称等情况）在数据库中查找符合条件的电影院记录，
* 并将查询到的结果以`List<Cinema>`集合形式返回，集合中的每个`Cinema`对象对应一条匹配的电影院记录。
* @param cinema_name 用于模糊查询的电影院名称
* @return 返回一个包含符合模糊查询条件的`Cinema`对象的`List`集合，可能为空集合（如果没有匹配记录）
*/
List<Cinema> findCinemasLikeName(String cinema_name);
/**
* 根据电影的唯一标识（ID）查找放映该电影的所有电影院信息的方法签名。
* 在实现类中需要编写SQL语句通过关联关系（具体关联逻辑取决于数据库表设计，比如通过电影场次表等中间关联表）查找放映指定电影的所有电影院记录，
* 然后以`List<Cinema>`集合形式返回这些电影院的信息列表，方便获取某部电影在哪些电影院有放映安排。
* @param movie_id 要查询放映其的电影院的电影的ID
* @return 返回一个包含放映指定电影的`Cinema`对象的`List`集合，可能为空集合（如果没有对应的放映安排）
*/
List<Cinema> findCinemasByMovieId(long movie_id);
}
Cinema findCinemaById(long cinema_id);
Integer addCinema(Cinema cinema);
Integer updateCinema(Cinema cinema);
Integer deleteCinema(long cinema_id);
List<Cinema> findAllCinemas();
List<Cinema> findCinemasLikeName(String cinema_name);
List<Cinema> findCinemasByMovieId(long movie_id);
}

107
src/main/java/com/mapper/CinemaMapper.xml
Unescape View File

@ -1,69 +1,46 @@
<?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">
<!-- 此 XML 文件为 MyBatis 的映射文件，其作用是定义与数据库交互的 SQL 语句以及结果集映射关系等配置内容，对应的接口为 com.mapper.CinemaMapper，主要用于处理电影院（Cinema）相关的数据操作。 -->
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.CinemaMapper">
<!-- 定义名为 BaseResultMap 的结果集映射，用于将从数据库查询返回的结果（按照列的形式）映射到 com.entity.Cinema 实体类对应的属性上，方便 MyBatis 将数据库记录转换为 Java 对象，便于后续在程序中使用。 -->
<resultMap type="com.entity.Cinema" id="BaseResultMap">
<!-- 将数据库表 cinema 中的 cinema_id 列的值映射到 Cinema 实体类的 cinema_id 属性上，属性类型为 long -->
<id property="cinema_id" column="cinema_id" javaType="long"/>
<!-- 将数据库表 cinema 中的 cinema_name 列的值映射到 Cinema 实体类的 cinema_name 属性上，属性类型为 java.lang.String -->
<result property="cinema_name" column="cinema_name" javaType="java.lang.String"/>
<!-- 将数据库表 cinema 中的 cinema_address 列的值映射到 Cinema 实体类的 cinema_address 属性上，属性类型为 java.lang.String -->
<result property="cinema_address" column="cinema_address" javaType="java.lang.String"/>
</resultMap>
<!-- 定义名为 findCinemaById 的查询语句，用于根据电影院的唯一标识（ID）从 cinema 表中查询对应的电影院信息。
参数类型为 long，表示传入的参数是一个长整型的电影院 ID，查询结果通过 BaseResultMap 定义的映射关系转换为 Cinema 实体对象返回。 -->
<select id="findCinemaById" parameterType="long" resultMap="BaseResultMap">
select * from cinema where cinema_id = #{cinema_id}
</select>
<!-- 定义名为 findAllCinemas 的查询语句，用于从 cinema 表中查询所有的电影院信息。
查询结果通过 BaseResultMap 定义的映射关系转换为 Cinema 实体对象，并以列表形式返回所有电影院记录对应的 Cinema 对象集合。 -->
<select id="findAllCinemas" resultMap="BaseResultMap">
select * from cinema
</select>
<!-- 定义名为 findCinemasLikeName 的查询语句，用于根据电影院名称进行模糊查询。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影院名称，通过使用 LIKE 关键字结合通配符 '%${value}%'（此处使用 ${} 是为了直接将传入的字符串拼接进 SQL 语句实现模糊匹配，需注意防止 SQL 注入问题），
在 cinema 表中查找名称符合模糊匹配条件的电影院记录，查询结果通过 BaseResultMap 映射为 Cinema 实体对象并返回对应的电影院集合。 -->
<select id="findCinemasLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from cinema where cinema_name like '%${value}%'
</select>
<!-- 定义名为 findCinemasByMovieId 的查询语句，用于根据电影的唯一标识（ID）查找放映该电影的所有电影院信息。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，通过多表关联查询（关联 hall 表、schedule 表和 cinema 表，根据各表中相应字段的关联关系，如 hall.hall_id=schedule.hall_id 和 hall.cinema_id=cinema.cinema_id 等），
筛选出放映指定电影（通过 schedule.movie_id = #{movie_id} 条件判断）的电影院记录，使用 DISTINCT 关键字去除重复记录后，查询结果通过 BaseResultMap 映射为 Cinema 实体对象并返回对应的电影院集合。 -->
<select id="findCinemasByMovieId" parameterType="long" resultMap="BaseResultMap">
select distinct cinema.* from hall,schedule,cinema
where hall.hall_id=schedule.hall_id and hall.cinema_id=cinema.cinema_id and schedule.movie_id = #{movie_id}
</select>
<!-- 定义名为 addCinema 的插入语句，用于向 cinema 表中插入一条新的电影院记录。
参数类型为 com.entity.Cinema，表示传入的参数是一个 Cinema 实体对象，从该对象中获取 cinema_name 和 cinema_address 属性值插入到 cinema 表对应的列中，实现新增电影院记录的操作。 -->
<insert id="addCinema" parameterType="com.entity.Cinema">
insert into cinema(cinema_name,cinema_address)
values(#{cinema_name},#{cinema_address})
</insert>
<!-- 定义名为 updateCinema 的更新语句，用于更新 cinema 表中指定电影院记录的信息。
参数类型为 com.entity.Cinema，表示传入的参数是一个 Cinema 实体对象，根据该对象中的 cinema_name 和 cinema_address 属性值来更新对应电影院记录的相应列的值，
更新条件是 cinema_id 列的值与传入对象的 cinema_id 属性值相等，通过 <set> 标签来动态生成需要更新的列，避免不必要的列更新为空值等情况。 -->
<update id="updateCinema" parameterType="com.entity.Cinema">
update cinema
<set>
cinema_name = #{cinema_name},
cinema_name = #{cinema_address}
</set>
where cinema_id = #{cinema_id}
</update>
<!-- 定义名为 deleteCinema 的删除语句，用于从 cinema 表中删除指定的电影院记录。
参数类型为 long，表示传入的参数是一个长整型的电影院 ID，根据该 ID 删除 cinema 表中对应的电影院记录，删除条件是 cinema_id 列的值与传入的参数值相等。 -->
<delete id="deleteCinema" parameterType="long">
delete from cinema where cinema_id = #{cinema_id}
</delete>
<resultMap type="com.entity.Cinema" id="BaseResultMap">
<id property="cinema_id" column="cinema_id" javaType="long"/>
<result property="cinema_name" column="cinema_name" javaType="java.lang.String"/>
<result property="cinema_address" column="cinema_address" javaType="java.lang.String"/>
</resultMap>
<select id="findCinemaById" parameterType="long" resultMap="BaseResultMap">
select * from cinema where cinema_id = #{cinema_id}
</select>
<select id="findAllCinemas" resultMap="BaseResultMap">
select * from cinema
</select>
<select id="findCinemasLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from cinema where cinema_name like '%${value}%'
</select>
<select id="findCinemasByMovieId" parameterType="long" resultMap="BaseResultMap">
select distinct cinema.* from hall,schedule,cinema
where hall.hall_id=schedule.hall_id and hall.cinema_id=cinema.cinema_id and schedule.movie_id = #{movie_id}
</select>
<insert id="addCinema" parameterType="com.entity.Cinema">
insert into cinema(cinema_name,cinema_address)
values(#{cinema_name},#{cinema_address})
</insert>
<update id="updateCinema" parameterType="com.entity.Cinema">
update cinema
<set>
cinema_name = #{cinema_name},
cinema_address = #{cinema_address}
</set>
where cinema_id = #{cinema_id}
</update>
<delete id="deleteCinema" parameterType="long">
delete from cinema where cinema_id = #{cinema_id}
</delete>
</mapper>

66
src/main/java/com/mapper/CommentMapper.java
Unescape View File

@ -8,58 +8,14 @@ import com.entity.Comment;
@Repository
public interface CommentMapper {
/**
* 根据评论ID查找特定的评论。
*
* @param comment_id 评论的唯一标识符
* @return 返回与给定ID匹配的评论对象，如果未找到则返回null
*/
Comment findCommentById(long comment_id);
/**
* 向数据库中添加新的评论。
*
* @param comment 要添加的评论对象
* @return 如果插入成功，则返回受影响的行数（通常是1），否则返回0
*/
Integer addComemnt(Comment comment);
/**
* 更新数据库中已有的评论。
*
* @param comment 包含更新信息的评论对象
* @return 如果更新成功，则返回受影响的行数（通常是1），否则返回0
*/
Integer updateComment(Comment comment);
/**
* 从数据库中删除指定ID的评论。
*
* @param comment_id 要删除的评论的唯一标识符
* @return 如果删除成功，则返回受影响的行数（通常是1），否则返回0
*/
Integer deleteComment(long comment_id);
/**
* 查询并返回数据库中的所有评论。
*
* @return 包含所有评论对象的列表
*/
List<Comment> findAllComments();
/**
* 根据电影ID查询该电影的所有评论。
*
* @param movie_id 电影的唯一标识符
* @return 包含与给定电影ID相关的所有评论对象的列表
*/
List<Comment> findCommentsByMoiveId(long movie_id);
/**
* 根据用户名查询该用户的所有评论。
*
* @param user_name 用户名
* @return 包含与给定用户名相关的所有评论对象的列表
*/
List<Comment> findCommentsByUserName(String user_name);
}
//用户： 修改评论、增加评论
//管理员： 删除评论、 修改评论
//查询用户的评论
Comment findCommentById(long comment_id);
Integer addComemnt(Comment comment);
Integer updateComment(Comment comment);
Integer deleteComment(long comment_id);
List<Comment> findAllComments();
List<Comment> findCommentsByMoiveId(long movie_id);
List<Comment> findCommentsByUserName(String user_name);
}

117
src/main/java/com/mapper/CommentMapper.xml
Unescape View File

@ -1,75 +1,50 @@
<?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">
<!-- 该 XML 文件为 MyBatis 的映射文件，用于定义与数据库交互的 SQL 语句以及结果集映射关系等配置。此映射文件对应的接口为 com.mapper.CommentMapper -->
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.CommentMapper">
<!-- 定义一个名为 BaseResultMap 的结果集映射，用于将从数据库查询返回的结果（以列的形式）映射到 com.entity.Comment 实体类的对应属性上。
这样 MyBatis 在执行查询操作后，能自动将数据库记录转换为对应的 Java 对象方便后续使用。 -->
<resultMap type="com.entity.Comment" id="BaseResultMap">
<!-- 将数据库表中的 comment_id 列的值映射到 Comment 实体类的 comment_id 属性上，属性类型为 long -->
<id property="comment_id" column="comment_id" javaType="long"/>
<!-- 将数据库表中的 comment_content 列的值映射到 Comment 实体类的 comment_content 属性上，属性类型为 java.lang.String -->
<result property="comment_content" column="comment_content" javaType="java.lang.String"/>
<!-- 将数据库表中的 comment_time 列的值映射到 Comment 实体类的 comment_time 属性上，属性类型为 java.util.Date -->
<result property="comment_time" column="comment_time" javaType="java.util.Date"/>
<!-- 将数据库表中的 movie_id 列的值映射到 Comment 实体类的 movie_id 属性上，属性类型为 long -->
<result property="movie_id" column="movie_id" javaType="long"/>
<!-- 将数据库表中的 user_id 列的值映射到 Comment 实体类的 user_id 属性上，属性类型为 long -->
<result property="user_id" column="user_id" javaType="long"/>
</resultMap>
<!-- 定义一个名为 findCommentById 的查询语句，用于根据评论的唯一标识（ID）从 comment 表中查询对应的评论信息。
参数类型为 long，表示传入的参数是一个长整型的评论 ID，查询结果通过 BaseResultMap 定义的映射关系转换为 Comment 实体对象返回。 -->
<select id="findCommentById" parameterType="long" resultMap="BaseResultMap">
select * from comment where comment_id = #{comment_id}
</select>
<!-- 定义一个名为 findAllComments 的查询语句，用于从 comment 表中查询所有的评论信息。
查询结果通过 BaseResultMap 定义的映射关系转换为 Comment 实体对象，并以列表形式返回所有的评论记录对应的 Comment 对象集合。 -->
<select id="findAllComments" resultMap="BaseResultMap">
select * from comment
</select>
<!-- 定义一个名为 findCommentsByUserName 的查询语句，用于根据用户名从 comment 表中查询该用户发表的所有评论信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的用户名，通过关联 comment 表和 user 表（根据 user_id 关联），筛选出指定用户名对应的评论记录，
结果同样通过 BaseResultMap 映射为 Comment 实体对象并返回对应的评论集合。 -->
<select id="findCommentsByUserName" parameterType="java.lang.String" resultMap="BaseResultMap">
select comment.* from comment,user where comment.user_id = user.user_id and user.user_name = #{user_name}
</select>
<!-- 定义一个名为 findCommentsByMoiveId 的查询语句，用于根据电影的唯一标识（ID）从 comment 表中查询该电影对应的所有评论信息。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，查询结果通过 BaseResultMap 映射为 Comment 实体对象并返回对应的评论集合。 -->
<select id="findCommentsByMoiveId" parameterType="long" resultMap="BaseResultMap">
select * from comment where movie_id = #{movie_id}
</select>
<!-- 定义一个名为 addComemnt 的插入语句，用于向 comment 表中插入一条新的评论记录。
参数类型为 com.entity.Comment，表示传入的参数是一个 Comment 实体对象，从该对象中获取相应属性值插入到 comment 表对应的列中，插入的列包括 comment_content、comment_time、movie_id 和 user_id。 -->
<insert id="addComemnt" parameterType="com.entity.Comment">
insert into comment(comment_content,comment_time,movie_id,user_id)
values(#{comment_content},#{comment_time},#{movie_id},#{user_id})
</insert>
<!-- 定义一个名为 updateComment 的更新语句，用于更新 comment 表中指定评论记录的信息。
参数类型为 com.entity.Comment，表示传入的参数是一个 Comment 实体对象，根据该对象中的属性值来更新对应评论记录的 comment_content、comment_time、movie_id 和 user_id 列的值，
更新条件是 comment_id 列的值与传入对象的 comment_id 属性值相等，通过 <set> 标签来动态生成需要更新的列，避免不必要的列更新为空值等情况。 -->
<update id="updateComment" parameterType="com.entity.Comment">
update comment
<set>
comment_content = #{comment_content},
comment_time = #{comment_time},
movie_id = #{movie_id},
user_id = #{user_id}
</set>
where comment_id = #{comment_id}
</update>
<!-- 定义一个名为 deleteComment 的删除语句，用于从 comment 表中删除指定评论记录。
参数类型为 long，表示传入的参数是一个长整型的评论 ID，根据该 ID 删除 comment 表中对应的评论记录，删除条件是 comment_id 列的值与传入的参数值相等。 -->
<delete id="deleteComment" parameterType="long">
delete from comment where comment_id = #{comment_id}
</delete>
<resultMap type="com.entity.Comment" id="BaseResultMap">
<id property="comment_id" column="comment_id" javaType="long"/>
<result property="comment_content" column="comment_content" javaType="java.lang.String"/>
<result property="comment_time" column="comment_time" javaType="java.util.Date"/>
<result property="movie_id" column="movie_id" javaType="long"/>
<result property="user_id" column="user_id" javaType="long"/>
</resultMap>
<select id="findCommentById" parameterType="long" resultMap="BaseResultMap">
select * from comment where comment_id = #{comment_id}
</select>
<select id="findAllComments" resultMap="BaseResultMap">
select * from comment
</select>
<select id="findCommentsByUserName" parameterType="java.lang.String" resultMap="BaseResultMap">
select comment.* from comment,user where comment.user_id = user.user_id and user.user_name = #{user_name}
</select>
<select id="findCommentsByMoiveId" parameterType="long" resultMap="BaseResultMap">
select * from comment where movie_id = #{movie_id}
</select>
<insert id="addComemnt" parameterType="com.entity.Comment">
insert into comment(comment_content,comment_time,movie_id,user_id)
values(#{comment_content},#{comment_time},#{movie_id},#{user_id})
</insert>
<update id="updateComment" parameterType="com.entity.Comment">
update comment
<set>
comment_content = #{comment_content},
comment_time = #{comment_time},
movie_id = #{movie_id},
user_id = #{user_id}
</set>
where comment_id = #{comment_id}
</update>
<delete id="deleteComment" parameterType="long">
delete from comment where comment_id = #{comment_id}
</delete>
</mapper>

75
src/main/java/com/mapper/HallMapper.java
Unescape View File

@ -7,71 +7,14 @@ import org.springframework.stereotype.Repository;
import com.entity.Hall;
/**
* HallMapper接口，用于定义针对放映厅（Hall）相关数据进行持久化操作（通常对应数据库操作）的方法签名。
* 该接口一般会由对应的Mapper实现类来具体实现其方法逻辑，从而实现与数据库的交互，例如查询、插入、更新以及删除放映厅信息等操作。
* 通过使用`@Repository`注解，将该接口标记为Spring的持久层组件，便于Spring框架进行管理以及依赖注入等操作。
*/
@Repository
public interface HallMapper {
/**
* 根据放映厅的唯一标识（ID）查询放映厅信息的方法签名。
* 对应的实现类中应该编写具体的SQL语句（例如使用MyBatis框架时在对应的XML映射文件中编写SQL）来从数据库中查找指定ID的放映厅记录，并将其映射为`Hall`实体对象返回。
* @param hall_id 要查询的放映厅的ID
* @return 返回一个`Hall`对象，代表查询到的放映厅信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Hall findHallById(long hall_id);
/**
* 根据影院名称和放映厅名称来查询放映厅信息的方法签名。
* 通过传入的影院名称和放映厅名称两个参数（使用`@Param`注解明确参数名，方便在SQL语句中引用），对应的实现类需编写SQL语句在数据库中查找同时满足这两个名称条件的放映厅记录，
* 并将其映射为`Hall`实体对象返回，可用于在已知影院及放映厅具体名称的情况下精准查找对应的放映厅信息。
* @param cinema_name 要查询的放映厅所属影院的名称
* @param hall_name 要查询的放映厅的名称
* @return 返回一个`Hall`对象，代表查询到的符合条件的放映厅信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Hall findHallByCinemaAndHallName(@Param("cinema_name") String cinema_name, @Param("hall_name") String hall_name);
/**
* 向数据库中插入一条新的放映厅记录的方法签名。
* 实现类中需要编写合适的SQL插入语句，将传入的`Hall`对象所包含的放映厅信息插入到数据库对应的表中，
* 并根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定）。
* @param hall 包含要插入的放映厅信息的`Hall`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addHall(Hall hall);
/**
* 根据传入的`Hall`对象信息更新数据库中对应的放映厅记录的方法签名。
* 实现类中要编写相应的SQL更新语句，依据`Hall`对象中的属性值来更新数据库里对应放映厅记录的相应字段，
* 同样根据更新操作结果返回受影响的行数，用于判断更新是否成功执行。
* @param hall 包含更新后放映厅信息的`Hall`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateHall(Hall hall);
/**
* 根据放映厅的唯一标识（ID）从数据库中删除对应的放映厅记录的方法签名。
* 实现类需编写SQL删除语句，将指定ID的放映厅记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况）。
* @param hall_id 要删除的放映厅的ID
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
Integer deleteHall(long hall_id);
/**
* 根据影院的唯一标识（ID）查询该影院下所有放映厅信息的方法签名。
* 对应的实现类应编写SQL查询语句，通过关联关系（具体关联逻辑取决于数据库表设计）从数据库中查找属于指定影院的所有放映厅记录，
* 并将每条记录映射为`Hall`实体对象，最后以`List<Hall>`集合的形式返回这些放映厅信息列表，方便获取某一影院包含的所有放映厅情况。
* @param cinema_id 要查询其下放映厅的影院的ID
* @return 返回一个包含所有符合条件的`Hall`对象的`List`集合，每个对象代表一条放映厅记录信息，可能为空集合（如果该影院没有放映厅）
*/
List<Hall> findHallByCinemaId(long cinema_id);
/**
* 查询数据库中所有放映厅信息的方法签名。
* 对应的实现类应编写SQL查询语句，从数据库表中获取全部的放映厅记录，并将每条记录映射为`Hall`实体对象，最后以`List<Hall>`集合的形式返回所有放映厅信息列表。
* @return 返回一个包含所有`Hall`对象的`List`集合，每个对象代表一条放映厅记录信息
*/
List<Hall> findAllHalls();
}
Hall findHallById(long hall_id);
Hall findHallByCinemaAndHallName(@Param("cinema_name")String cinema_name,@Param("hall_name")String hall_name);
Integer addHall(Hall hall);
Integer updateHall(Hall hall);
Integer deleteHall(long hall_id);
List<Hall> findHallByCinemaId(long cinema_id);
List<Hall> findAllHalls();
}

189
src/main/java/com/mapper/HallMapper.xml
Unescape View File

@ -1,149 +1,46 @@
<?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">
<!-- 此 XML 文件为 MyBatis 的映射文件，用于定义与数据库交互的 SQL 语句以及结果集映射关系等配置内容，其对应的接口是 com.mapper.MovieMapper，主要负责处理电影（Movie）相关的数据操作。 -->
<mapper namespace="com.mapper.MovieMapper">
<!-- 定义名为 BaseResultMap 的结果集映射，用于将从数据库查询返回的结果（按照列的形式）映射到 com.entity.Movie 实体类对应的属性上，方便 MyBatis 将数据库记录转换为 Java 对象，便于后续在程序中使用。 -->
<resultMap type="com.entity.Movie" id="BaseResultMap">
<!-- 将数据库表 movie 中的 movie_id 列的值映射到 Movie 实体类的 movie_id 属性上，属性类型为 long -->
<id property="movie_id" column="movie_id" javaType="long"/>
<!-- 将数据库表 movie 中的 movie_actor 列的值映射到 Movie 实体类的 movie_actor 属性上，属性类型为 java.lang.String -->
<result property="movie_actor" column="movie_actor" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_boxOffice 列的值映射到 Movie 实体类的 movie_boxOffice 属性上，属性类型为 float -->
<result property="movie_boxOffice" column="movie_boxOffice" javaType="float"/>
<!-- 将数据库表 movie 中的 movie_cn_name 列的值映射到 Movie 实体类的 movie_cn_name 属性上，属性类型为 java.lang.String -->
<result property="movie_cn_name" column="movie_cn_name" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_commentCount 列的值映射到 Movie 实体类的 movie_commentCount 属性上，属性类型为 long -->
<result property="movie_commentCount" column="movie_commentCount" javaType="long"/>
<!-- 将数据库表 movie 中的 movie_country 列的值映射到 Movie 实体类的 movie_country 属性上，属性类型为 java.lang.String -->
<result property="movie_country" column="movie_country" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_detail 列的值映射到 Movie 实体类的 movie_detail 属性上，属性类型为 java.lang.String -->
<result property="movie_detail" column="movie_detail" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_director 列的值映射到 Movie 实体类的 movie_director 属性上，属性类型为 java.lang.String -->
<result property="movie_director" column="movie_director" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_duration 列的值映射到 Movie 实体类的 movie_duration 属性上，属性类型为 java.lang.String -->
<result property="movie_duration" column="movie_duration" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_fg_name 列的值映射到 Movie 实体类的 movie_fg_name 属性上，属性类型为 java.lang.String -->
<result property="movie_fg_name" column="movie_fg_name" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_picture 列的值映射到 Movie 实体类的 movie_picture 属性上，属性类型为 java.lang.String -->
<result property="movie_picture" column="movie_picture" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_score 列的值映射到 Movie 实体类的 movie_score 属性上，属性类型为 float -->
<result property="movie_score" column="movie_score" javaType="float"/>
<!-- 将数据库表 movie 中的 movie_type 列的值映射到 Movie 实体类的 movie_type 属性上，属性类型为 java.lang.String -->
<result property="movie_type" column="movie_type" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_releaseDate 列的值映射到 Movie 实体类的 movie_releaseDate 属性上，属性类型为 java.sql.Date -->
<result property="movie_releaseDate" column="movie_releaseDate" javaType="java.sql.Date"/>
<!-- 将数据库表 movie 中的 movie_state 列的值映射到 Movie 实体类的 movie_state 属性上，属性类型为 java.lang.Integer -->
<result property="movie_state" column="movie_state" javaType="java.lang.Integer"/>
</resultMap>
<!-- 定义名为 findMovieById 的查询语句，用于根据电影的唯一标识（ID）从 movie 表中查询对应的电影信息。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象返回。 -->
<select id="findMovieById" parameterType="long" resultMap="BaseResultMap">
select * from movie where movie_id = #{movie_id}
</select>
<!-- 定义名为 findMovieByName 的查询语句，用于根据电影的中文名称从 movie 表中查询对应的电影信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影中文名称，查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象返回。 -->
<select id="findMovieByName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_cn_name = #{movie_cn_name}
</select>
<!-- 定义名为 addMovie 的插入语句，用于向 movie 表中插入一条新的电影记录。
参数类型为 com.entity.Movie，表示传入的参数是一个 Movie 实体对象，从该对象中获取 movie_cn_name、movie_fg_name、movie_actor、movie_director、movie_detail、movie_duration、movie_type、movie_score、movie_releaseDate、movie_country 和 movie_picture 等属性值，插入到 movie 表对应的列中，实现新增电影记录的操作。 -->
<insert id="addMovie" parameterType="com.entity.Movie">
insert into movie(movie_cn_name,movie_fg_name,movie_actor,movie_director,movie_detail,movie_duration,movie_type,movie_score,movie_releaseDate,movie_country,movie_picture)
values(#{movie_cn_name},#{movie_fg_name},#{movie_actor},#{movie_director},#{movie_detail},#{movie_duration},#{movie_type},#{movie_score},#{movie_releaseDate},#{movie_country},#{movie_picture})
</insert>
<!-- 定义名为 deleteMovie 的更新语句，用于将指定电影记录的状态标记为下架（这里将 movie_state 设置为 0，通常表示下架状态）。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，根据该 ID 更新 movie 表中对应电影记录的 movie_state 字段值，以此实现电影下架的逻辑操作。 -->
<update id="deleteMovie" parameterType="long">
update movie
<set>
movie_state = 0
</set>
where movie_id = #{movie_id}
</update>
<!-- 定义名为 changeMovieBoxOffice 的更新语句，用于更新指定电影的票房数据，将原票房数值加上传入的票房增量值。
这里通过 SQL 语句中的 movie_boxOffice = movie_boxOffice + #{movie_boxOffice} 实现票房的累加更新操作，更新条件是 movie_id 列的值与传入的电影 ID 参数值相等，用于在电影有新的票房收入时更新数据库中的票房数据。 -->
<update id="changeMovieBoxOffice">
update movie set movie_boxOffice = movie_boxOffice + #{movie_boxOffice} where movie_id = #{movie_id}
</update>
<!-- 定义名为 updateMovie 的更新语句，用于更新 movie 表中指定电影记录的部分信息（除了 movie_id、movie_state 等未在 <set> 标签内列出的字段，通常这些字段在更新时可能有特殊逻辑或不常变动）。
参数类型为 com.entity.Movie，表示传入的参数是一个 Movie 实体对象，根据该对象中的 movie_cn_name、movie_fg_name、movie_actor、movie_director、movie_detail、movie_duration、movie_type、movie_country 和 movie_picture 等属性值来更新对应电影记录的相应列的值，更新条件是 movie_id 列的值与传入对象的 movie_id 属性值相等，通过 <set> 标签来动态生成需要更新的列，避免不必要的列更新为空值等情况。 -->
<update id="updateMovie" parameterType="com.entity.Movie">
update movie
<set>
movie_cn_name = #{movie_cn_name},
movie_fg_name = #{movie_fg_name},
movie_actor = #{movie_actor},
movie_director = #{movie_director},
movie_detail = #{movie_detail},
movie_duration = #{movie_duration},
movie_type = #{movie_type},
movie_country = #{movie_country},
movie_picture = #{movie_picture}
</set>
where movie_id = #{movie_id}
</update>
<!-- 定义名为 deleteMovieCommentCount 的更新语句，用于将指定电影的评论人数（movie_commentCount 字段）减 1，通常用于在有用户删除对应电影的评论等情况下更新评论人数统计数据。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，根据该 ID 更新 movie 表中对应电影记录的 movie_commentCount 字段值，实现评论人数的递减操作。 -->
<update id="deleteMovieCommentCount" parameterType="long">
update movie set movie_commentCount = movie_commentCount - 1 where movie_id = #{movie_id}
</update>
<!-- 定义名为 addMovieCommentCount 的更新语句，用于将指定电影的评论人数（movie_commentCount 字段）加 1，比如在有新用户对该电影发表评论时调用此方法来更新评论人数统计数据。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，根据该 ID 更新 movie 表中对应电影记录的 movie_commentCount 字段值，实现评论人数的递增操作。 -->
<update id="addMovieCommentCount" parameterType="long">
update movie set movie_commentCount = movie_commentCount + 1 where movie_id = #{movie_id}
</update>
<!-- 定义名为 findAllMovies 的查询语句，用于根据电影的状态查询所有符合该状态的电影信息。
参数类型为 java.lang.Integer，表示传入的参数是一个整数类型的电影状态值，查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回所有符合该状态的电影记录对应的 Movie 对象集合，方便按状态获取电影列表，例如获取所有在线（状态值表示在线的情况）的电影信息等。 -->
<select id="findAllMovies" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select * from movie where movie_state = #{movie_state}
</select>
<!-- 定义名为 findMoviesLikeName 的查询语句，用于根据电影的中文名称进行模糊查询，并且只查询处于在线状态（movie_state = 1，通常 1 表示在线）的电影信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影中文名称，通过使用 LIKE 关键字结合通配符 '%${value}%'（此处使用 ${} 是为了直接将传入的字符串拼接进 SQL 语句实现模糊匹配，需注意防止 SQL 注入问题），在 movie 表中查找名称符合模糊匹配条件且状态为在线的电影记录，查询结果通过 BaseResultMap 映射为 Movie 实体对象并返回对应的电影集合，常用于电影搜索功能实现。 -->
<select id="findMoviesLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_cn_name like '%${value}%' and movie_state = 1
</select>
<!-- 定义名为 findMoviesLikeType 的查询语句，用于根据电影类型进行模糊查询，并且只查询处于在线状态（movie_state = 1）的电影信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影类型，通过使用 LIKE 关键字结合通配符 '%${value}%' 在 movie 表中查找类型符合模糊匹配条件且状态为在线的电影记录，查询结果通过 BaseResultMap 映射为 Movie 实体对象并返回对应的电影集合，便于用户按类型查找感兴趣的电影。 -->
<select id="findMoviesLikeType" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_type like '%${value}%' and movie_state = 1
</select>
<!-- 定义名为 sortMovieByDate 的查询语句，用于按照电影的上映时间（movie_releaseDate 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，方便按照上映时间展示电影，例如展示新上映电影在前的列表等情况。 -->
<select id="sortMovieByDate" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_releaseDate DESC
</select>
<!-- 定义名为 sortMovieByCount 的查询语句，用于按照电影的评论人数（movie_commentCount 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，可用于展示热门评论电影等相关业务场景，例如评论数多的电影排在前面。 -->
<select id="sortMovieByCount" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_commentCount DESC
</select>
<!-- 定义名为 sortMovieByScore 的查询语句，用于按照电影的评分（movie_score 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，有助于展示高分电影在前等排序结果给用户查看，方便用户选择评分较高的电影。 -->
<select id="sortMovieByScore" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_score DESC
</select>
<!-- 定义名为 sortMovieByBoxOffice 的查询语句，用于按照电影的票房（movie_boxOffice 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，方便展示票房排名情况等业务场景，例如票房排行榜等，让用户可以看到票房较高的电影。 -->
<select id="sortMovieByBoxOffice" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_boxOffice desc
</select>
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.HallMapper">
<resultMap type="com.entity.Hall" id="BaseResultMap">
<id property="hall_id" column="hall_id" javaType="long"/>
<result property="hall_name" column="hall_name" javaType="java.lang.String"/>
<result property="cinema_id" column="cinema_id" javaType="long"/>
</resultMap>
<select id="findHallById" parameterType="long" resultMap="BaseResultMap">
select * from hall where hall_id = #{hall_id}
</select>
<select id="findHallByCinemaAndHallName" resultMap="BaseResultMap">
select hall.* from hall,cinema where hall.cinema_id = cinema.cinema_id
and cinema_name = #{cinema_name} and hall_name= #{hall_name}
</select>
<select id="findHallByCinemaId" parameterType="long" resultMap="BaseResultMap">
select * from hall where cinema_id = #{cinema_id}
</select>
<select id="findAllHalls" resultMap="BaseResultMap">
select * from hall
</select>
<insert id="addHall" parameterType="com.entity.Hall">
insert into hall(hall_name,movie_id)
values(hall_name,movie_id)
</insert>
<update id="updateHall" parameterType="com.entity.Hall">
update hall
<set>
hall_name = #{hall_name},
movie_id = #{movie_id}
</set>
where hall_id = #{hall_id}
</update>
<delete id="deleteHall" parameterType="long">
delete from hall where hall_id = #{hall_id}
</delete>
</mapper>

153
src/main/java/com/mapper/MovieMapper.java
Unescape View File

@ -7,140 +7,23 @@ import org.springframework.stereotype.Repository;
import com.entity.Movie;
/**
* MovieMapper接口，用于定义对电影（Movie）相关数据进行持久化操作（通常对应数据库操作）的方法签名。
* 该接口一般会由对应的Mapper实现类来具体实现其方法逻辑，进而实现与数据库的交互，例如查询、插入、更新以及删除电影信息，还有针对电影一些统计数据（如评论数、票房等）的操作等功能。
* 通过使用`@Repository`注解，将该接口标记为Spring的持久层组件，便于Spring框架进行管理以及依赖注入等操作。
*/
@Repository
public interface MovieMapper {
/**
* 根据电影的唯一标识（ID）查询电影信息的方法签名。
* 对应的实现类中需要编写具体的SQL语句（例如在使用MyBatis框架时，在对应的XML映射文件中编写SQL），从数据库中查找指定ID的电影记录，并将其映射为`Movie`实体对象返回，方便获取特定电影的详细信息。
* @param movie_id 要查询的电影的ID
* @return 返回一个`Movie`对象，代表查询到的电影信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Movie findMovieById(long movie_id);
/**
* 根据电影的中文名称查询电影信息的方法签名。
* 实现类需编写相应的SQL语句，依据传入的电影中文名称在数据库中查找对应的电影记录，并将其映射为`Movie`实体对象返回，便于通过电影名称来获取其具体信息，可用于搜索等功能实现。
* @param movie_cn_name 要查询的电影的中文名称
* @return 返回一个`Movie`对象，代表查询到的符合条件的电影信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Movie findMovieByName(String movie_cn_name);
/**
* 向数据库中插入一条新的电影记录的方法签名。
* 实现类中要编写合适的SQL插入语句，将传入的`Movie`对象所包含的电影信息（如名称、导演、演员等各种属性值）插入到数据库对应的表中，
* 并根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），用于判断电影信息插入是否成功。
* @param movie 包含要插入的电影信息的`Movie`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addMovie(Movie movie);
/**
* 根据电影的唯一标识（ID）从数据库中删除对应的电影记录的方法签名。
* 实现类需编写SQL删除语句，将指定ID的电影记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况），用于确认电影记录删除操作的结果。
* @param movie_id 要删除的电影的ID
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
Integer deleteMovie(long movie_id);
/**
* 根据传入的`Movie`对象信息更新数据库中对应的电影记录的方法签名。
* 实现类中要编写相应的SQL更新语句，依据`Movie`对象中的属性值（例如电影详情、时长等属性发生变化时）来更新数据库里对应电影记录的相应字段，
* 同样根据更新操作结果返回受影响的行数，用于判断电影记录更新是否成功执行。
* @param movie 包含更新后电影信息的`Movie`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateMovie(Movie movie);
/**
* 根据电影的唯一标识（ID）将该电影的参评人数（评论计数相关字段）清零或者进行相应删除操作的方法签名。
* 具体实现类中的SQL语句会针对指定ID的电影在数据库中操作其评论人数相关字段（可能是将值设为0或者删除相关关联记录等，具体依业务逻辑而定），
* 并返回受影响的行数来体现操作是否成功执行，此操作常用于电影相关数据重置等业务场景。
* @param movie_id 要操作其评论人数的电影的ID
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer deleteMovieCommentCount(long movie_id);
/**
* 根据电影的唯一标识（ID）增加该电影的参评人数（评论计数相关字段）的方法签名。
* 实现类需编写SQL语句，针对指定ID的电影在数据库中对其评论人数相关字段进行增加操作（比如评论新增时调用此方法来更新评论数），
* 并返回受影响的行数来表明操作是否成功执行，以此来更新电影的评论参与人数统计数据。
* @param movie_id 要增加其评论人数的电影的ID
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer addMovieCommentCount(long movie_id);
/**
* 根据传入的电影票房数值和电影的唯一标识（ID），更新该电影的票房数据的方法签名。
* 通过`@Param`注解明确了两个参数名，方便在SQL语句中准确引用参数值，实现类编写的SQL语句会依据传入的票房数值和电影ID，在数据库中更新对应电影记录的票房字段，
* 同样返回受影响的行数用于判断票房数据更新操作是否成功执行，常用于电影票房数据变化（如新增票房收入等情况）时的更新操作。
* @param movie_boxOffice 要更新的电影票房数值，以浮点数形式传入
* @param movie_id 要更新票房数据的电影的ID
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer changeMovieBoxOffice(@Param("movie_boxOffice") float movie_boxOffice, @Param("movie_id") long movie_id);
/**
* 根据电影的状态（如在线、下架等状态标识）查询所有符合该状态的电影信息的方法签名。
* 实现类编写的SQL语句会依据传入的电影状态值（通常是一个整数表示不同状态，例如1表示在线，0表示下架等），从数据库中筛选出处于该状态的所有电影记录，
* 并将每条记录映射为`Movie`实体对象，最后以`List<Movie>`集合的形式返回这些电影信息列表，方便按状态获取电影列表，用于展示不同状态下的电影等业务场景。
* @param movie_state 表示电影状态的整数，用于筛选符合该状态的电影记录
* @return 返回一个包含所有符合条件的`Movie`对象的`List`集合，每个对象代表一条电影记录信息，可能为空集合（如果没有符合该状态的电影）
*/
List<Movie> findAllMovies(int movie_state);
/**
* 根据电影名称进行模糊查询所有符合模糊条件的电影信息的方法签名。
* 实现类编写的SQL语句会按照传入的电影名称（支持模糊匹配的方式，例如包含部分名称等情况）在数据库中查找符合条件的电影记录，
* 并将查询到的结果以`List<Movie>`集合形式返回，集合中的每个`Movie`对象对应一条匹配的电影记录，常用于电影搜索功能实现。
* @param name 用于模糊查询的电影名称字符串
* @return 返回一个包含符合模糊查询条件的`Movie`对象的`List`集合，可能为空集合（如果没有匹配记录）
*/
List<Movie> findMoviesLikeName(String name);
/**
* 根据电影类型进行模糊查询所有符合模糊条件的电影信息的方法签名。
* 实现类编写的SQL语句会依据传入的电影类型（支持模糊匹配，比如查找包含“动作”字样的所有动作类电影等情况）在数据库中查找符合条件的电影记录，
* 并将查询到的结果以`List<Movie>`集合形式返回，集合中的每个`Movie`对象对应一条匹配的电影记录，便于用户按类型查找感兴趣的电影。
* @param type 用于模糊查询的电影类型字符串
* @return 返回一个包含符合模糊查询条件的`Movie`对象的`List`集合，可能为空集合（如果没有匹配记录）
*/
List<Movie> findMoviesLikeType(String type);
/**
* 按照电影的上映时间对所有电影进行排序并返回排序后的电影信息列表的方法签名。
* 实现类编写的SQL语句会在数据库中根据电影的上映时间字段进行排序操作（升序或降序，具体顺序可能依业务需求而定），
* 然后将排序后的电影记录映射为`Movie`实体对象，最后以`List<Movie>`集合的形式返回排序后的电影信息列表，方便按照上映时间展示电影，例如展示新上映电影列表等。
* @return 返回一个包含按照上映时间排序后的`Movie`对象的`List`集合，可能为空集合（如果没有电影记录）
*/
List<Movie> sortMovieByDate();
/**
* 按照电影的参评人数（评论计数相关）对所有电影进行排序并返回排序后的电影信息列表的方法签名。
* 实现类编写的SQL语句会在数据库中依据电影的参评人数字段进行排序操作（升序或降序，依业务需求而定），
* 再将排序后的电影记录映射为`Movie`实体对象，最后以`List<Movie>`集合的形式返回排序后的电影信息列表，可用于展示热门评论电影等相关业务场景。
* @return 返回一个包含按照参评人数排序后的`Movie`对象的`List`集合，可能为空集合（如果没有电影记录）
*/
List<Movie> sortMovieByCount();
/**
* 按照电影的评分对所有电影进行排序并返回排序后的电影信息列表的方法签名。
* 实现类编写的SQL语句会在数据库中根据电影的评分字段进行排序操作（升序或降序，按业务需求确定），
* 并将排序后的电影记录映射为`Movie`实体对象，最后以`List<Movie>`集合的形式返回排序后的电影信息列表，有助于展示高分电影、低分电影等不同排序结果给用户查看。
* @return 返回一个包含按照评分排序后的`Movie`对象的`List`集合，可能为空集合（如果没有电影记录）
*/
List<Movie> sortMovieByScore();
/**
* 按照电影的票房对所有电影进行排序并返回排序后的电影信息列表的方法签名。
* 实现类编写的SQL语句会在数据库中依据电影的票房字段进行排序操作（升序或降序，取决于业务需求），
* 然后将排序后的电影记录映射为`Movie`实体对象，最后以`List<Movie>`集合的形式返回排序后的电影信息列表，方便展示票房排名情况等业务场景，例如票房排行榜等。
* @return 返回一个包含按照票房排序后的`Movie`对象的`List`集合，可能为空集合（如果没有电影记录）
*/
List<Movie> sortMovieByBoxOffice();
}
Movie findMovieById(long movie_id);
Movie findMovieByName(String movie_cn_name);
Integer addMovie(Movie movie);
Integer deleteMovie(long movie_id);
Integer updateMovie(Movie movie);
Integer deleteMovieCommentCount(long movie_id);
Integer addMovieCommentCount(long movie_id);
Integer changeMovieBoxOffice(@Param("movie_boxOffice")float movie_boxOffice,@Param("movie_id")long movie_id);
List<Movie> findAllMovies(int movie_state);
List<Movie> findMoviesLikeName(String name);
List<Movie> findMoviesLikeType(String type);
//上映时间 参评人数 评分
List<Movie> sortMovieByDate();
List<Movie> sortMovieByCount();
List<Movie> sortMovieByScore();
//票房排序
List<Movie> sortMovieByBoxOffice();
}

242
src/main/java/com/mapper/MovieMapper.xml
Unescape View File

@ -1,149 +1,101 @@
<?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">
<!-- 此 XML 文件为 MyBatis 的映射文件，用于定义与数据库交互的 SQL 语句以及结果集映射关系等配置内容，其对应的接口是 com.mapper.MovieMapper，主要负责处理电影（Movie）相关的数据操作。 -->
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.MovieMapper">
<!-- 定义名为 BaseResultMap 的结果集映射，用于将从数据库查询返回的结果（按照列的形式）映射到 com.entity.Movie 实体类对应的属性上，方便 MyBatis 将数据库记录转换为 Java 对象，便于后续在程序中使用。 -->
<resultMap type="com.entity.Movie" id="BaseResultMap">
<!-- 将数据库表 movie 中的 movie_id 列的值映射到 Movie 实体类的 movie_id 属性上，属性类型为 long -->
<id property="movie_id" column="movie_id" javaType="long"/>
<!-- 将数据库表 movie 中的 movie_actor 列的值映射到 Movie 实体类的 movie_actor 属性上，属性类型为 java.lang.String -->
<result property="movie_actor" column="movie_actor" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_boxOffice 列的值映射到 Movie 实体类的 movie_boxOffice 属性上，属性类型为 float -->
<result property="movie_boxOffice" column="movie_boxOffice" javaType="float"/>
<!-- 将数据库表 movie 中的 movie_cn_name 列的值映射到 Movie 实体类的 movie_cn_name 属性上，属性类型为 java.lang.String -->
<result property="movie_cn_name" column="movie_cn_name" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_commentCount 列的值映射到 Movie 实体类的 movie_commentCount 属性上，属性类型为 long -->
<result property="movie_commentCount" column="movie_commentCount" javaType="long"/>
<!-- 将数据库表 movie 中的 movie_country 列的值映射到 Movie 实体类的 movie_country 属性上，属性类型为 java.lang.String -->
<result property="movie_country" column="movie_country" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_detail 列的值映射到 Movie 实体类的 movie_detail 属性上，属性类型为 java.lang.String -->
<result property="movie_detail" column="movie_detail" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_director 列的值映射到 Movie 实体类的 movie_director 属性上，属性类型为 java.lang.String -->
<result property="movie_director" column="movie_director" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_duration 列的值映射到 Movie 实体类的 movie_duration 属性上，属性类型为 java.lang.String -->
<result property="movie_duration" column="movie_duration" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_fg_name 列的值映射到 Movie 实体类的 movie_fg_name 属性上，属性类型为 java.lang.String -->
<result property="movie_fg_name" column="movie_fg_name" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_picture 列的值映射到 Movie 实体类的 movie_picture 属性上，属性类型为 java.lang.String -->
<result property="movie_picture" column="movie_picture" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_score 列的值映射到 Movie 实体类的 movie_score 属性上，属性类型为 float -->
<result property="movie_score" column="movie_score" javaType="float"/>
<!-- 将数据库表 movie 中的 movie_type 列的值映射到 Movie 实体类的 movie_type 属性上，属性类型为 java.lang.String -->
<result property="movie_type" column="movie_type" javaType="java.lang.String"/>
<!-- 将数据库表 movie 中的 movie_releaseDate 列的值映射到 Movie 实体类的 movie_releaseDate 属性上，属性类型为 java.sql.Date -->
<result property="movie_releaseDate" column="movie_releaseDate" javaType="java.sql.Date"/>
<!-- 将数据库表 movie 中的 movie_state 列的值映射到 Movie 实体类的 movie_state 属性上，属性类型为 java.lang.Integer -->
<result property="movie_state" column="movie_state" javaType="java.lang.Integer"/>
</resultMap>
<!-- 定义名为 findMovieById 的查询语句，用于根据电影的唯一标识（ID）从 movie 表中查询对应的电影信息。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象返回。 -->
<select id="findMovieById" parameterType="long" resultMap="BaseResultMap">
select * from movie where movie_id = #{movie_id}
</select>
<!-- 定义名为 findMovieByName 的查询语句，用于根据电影的中文名称从 movie 表中查询对应的电影信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影中文名称，查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象返回。 -->
<select id="findMovieByName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_cn_name = #{movie_cn_name}
</select>
<!-- 定义名为 addMovie 的插入语句，用于向 movie 表中插入一条新的电影记录。
参数类型为 com.entity.Movie，表示传入的参数是一个 Movie 实体对象，从该对象中获取 movie_cn_name、movie_fg_name、movie_actor、movie_director、movie_detail、movie_duration、movie_type、movie_score、movie_releaseDate、movie_country 和 movie_picture 等属性值，插入到 movie 表对应的列中，实现新增电影记录的操作。 -->
<insert id="addMovie" parameterType="com.entity.Movie">
insert into movie(movie_cn_name,movie_fg_name,movie_actor,movie_director,movie_detail,movie_duration,movie_type,movie_score,movie_releaseDate,movie_country,movie_picture)
values(#{movie_cn_name},#{movie_fg_name},#{movie_actor},#{movie_director},#{movie_detail},#{movie_duration},#{movie_type},#{movie_score},#{movie_releaseDate},#{movie_country},#{movie_picture})
</insert>
<!-- 定义名为 deleteMovie 的更新语句，用于将指定电影记录的状态标记为下架（这里将 movie_state 设置为 0，通常表示下架状态）。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，根据该 ID 更新 movie 表中对应电影记录的 movie_state 字段值，以此实现电影下架的逻辑操作。 -->
<update id="deleteMovie" parameterType="long">
update movie
<set>
movie_state = 0
</set>
where movie_id = #{movie_id}
</update>
<!-- 定义名为 changeMovieBoxOffice 的更新语句，用于更新指定电影的票房数据，将原票房数值加上传入的票房增量值。
这里通过 SQL 语句中的 movie_boxOffice = movie_boxOffice + #{movie_boxOffice} 实现票房的累加更新操作，更新条件是 movie_id 列的值与传入的电影 ID 参数值相等，用于在电影有新的票房收入时更新数据库中的票房数据。 -->
<update id="changeMovieBoxOffice">
update movie set movie_boxOffice = movie_boxOffice + #{movie_boxOffice} where movie_id = #{movie_id}
</update>
<!-- 定义名为 updateMovie 的更新语句，用于更新 movie 表中指定电影记录的部分信息（除了 movie_id、movie_state 等未在 <set> 标签内列出的字段，通常这些字段在更新时可能有特殊逻辑或不常变动）。
参数类型为 com.entity.Movie，表示传入的参数是一个 Movie 实体对象，根据该对象中的 movie_cn_name、movie_fg_name、movie_actor、movie_director、movie_detail、movie_duration、movie_type、movie_country 和 movie_picture 等属性值来更新对应电影记录的相应列的值，更新条件是 movie_id 列的值与传入对象的 movie_id 属性值相等，通过 <set> 标签来动态生成需要更新的列，避免不必要的列更新为空值等情况。 -->
<update id="updateMovie" parameterType="com.entity.Movie">
update movie
<set>
movie_cn_name = #{movie_cn_name},
movie_fg_name = #{movie_fg_name},
movie_actor = #{movie_actor},
movie_director = #{movie_director},
movie_detail = #{movie_detail},
movie_duration = #{movie_duration},
movie_type = #{movie_type},
movie_country = #{movie_country},
movie_picture = #{movie_picture}
</set>
where movie_id = #{movie_id}
</update>
<!-- 定义名为 deleteMovieCommentCount 的更新语句，用于将指定电影的评论人数（movie_commentCount 字段）减 1，通常用于在有用户删除对应电影的评论等情况下更新评论人数统计数据。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，根据该 ID 更新 movie 表中对应电影记录的 movie_commentCount 字段值，实现评论人数的递减操作。 -->
<update id="deleteMovieCommentCount" parameterType="long">
update movie set movie_commentCount = movie_commentCount - 1 where movie_id = #{movie_id}
</update>
<!-- 定义名为 addMovieCommentCount 的更新语句，用于将指定电影的评论人数（movie_commentCount 字段）加 1，比如在有新用户对该电影发表评论时调用此方法来更新评论人数统计数据。
参数类型为 long，表示传入的参数是一个长整型的电影 ID，根据该 ID 更新 movie 表中对应电影记录的 movie_commentCount 字段值，实现评论人数的递增操作。 -->
<update id="addMovieCommentCount" parameterType="long">
update movie set movie_commentCount = movie_commentCount + 1 where movie_id = #{movie_id}
</update>
<!-- 定义名为 findAllMovies 的查询语句，用于根据电影的状态查询所有符合该状态的电影信息。
参数类型为 java.lang.Integer，表示传入的参数是一个整数类型的电影状态值，查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回所有符合该状态的电影记录对应的 Movie 对象集合，方便按状态获取电影列表，例如获取所有在线（状态值表示在线的情况）的电影信息等。 -->
<select id="findAllMovies" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select * from movie where movie_state = #{movie_state}
</select>
<!-- 定义名为 findMoviesLikeName 的查询语句，用于根据电影的中文名称进行模糊查询，并且只查询处于在线状态（movie_state = 1，通常 1 表示在线）的电影信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影中文名称，通过使用 LIKE 关键字结合通配符 '%${value}%'（此处使用 ${} 是为了直接将传入的字符串拼接进 SQL 语句实现模糊匹配，需注意防止 SQL 注入问题），在 movie 表中查找名称符合模糊匹配条件且状态为在线的电影记录，查询结果通过 BaseResultMap 映射为 Movie 实体对象并返回对应的电影集合，常用于电影搜索功能实现。 -->
<select id="findMoviesLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_cn_name like '%${value}%' and movie_state = 1
</select>
<!-- 定义名为 findMoviesLikeType 的查询语句，用于根据电影类型进行模糊查询，并且只查询处于在线状态（movie_state = 1）的电影信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的电影类型，通过使用 LIKE 关键字结合通配符 '%${value}%' 在 movie 表中查找类型符合模糊匹配条件且状态为在线的电影记录，查询结果通过 BaseResultMap 映射为 Movie 实体对象并返回对应的电影集合，便于用户按类型查找感兴趣的电影。 -->
<select id="findMoviesLikeType" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_type like '%${value}%' and movie_state = 1
</select>
<!-- 定义名为 sortMovieByDate 的查询语句，用于按照电影的上映时间（movie_releaseDate 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，方便按照上映时间展示电影，例如展示新上映电影在前的列表等情况。 -->
<select id="sortMovieByDate" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_releaseDate DESC
</select>
<!-- 定义名为 sortMovieByCount 的查询语句，用于按照电影的评论人数（movie_commentCount 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，可用于展示热门评论电影等相关业务场景，例如评论数多的电影排在前面。 -->
<select id="sortMovieByCount" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_commentCount DESC
</select>
<!-- 定义名为 sortMovieByScore 的查询语句，用于按照电影的评分（movie_score 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，有助于展示高分电影在前等排序结果给用户查看，方便用户选择评分较高的电影。 -->
<select id="sortMovieByScore" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_score DESC
</select>
<!-- 定义名为 sortMovieByBoxOffice 的查询语句，用于按照电影的票房（movie_boxOffice 字段）对所有处于在线状态（movie_state = 1）的电影进行降序排序，并返回排序后的电影信息列表。
查询结果通过 BaseResultMap 定义的映射关系转换为 Movie 实体对象，并以列表形式返回排序后的电影记录对应的 Movie 对象集合，方便展示票房排名情况等业务场景，例如票房排行榜等，让用户可以看到票房较高的电影。 -->
<select id="sortMovieByBoxOffice" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_boxOffice desc
</select>
<resultMap type="com.entity.Movie" id="BaseResultMap">
<id property="movie_id" column="movie_id" javaType="long"/>
<result property="movie_actor" column="movie_actor" javaType="java.lang.String"/>
<result property="movie_boxOffice" column="movie_boxOffice" javaType="float"/>
<result property="movie_cn_name" column="movie_cn_name" javaType="java.lang.String"/>
<result property="movie_commentCount" column="movie_commentCount" javaType="long"/>
<result property="movie_country" column="movie_country" javaType="java.lang.String"/>
<result property="movie_detail" column="movie_detail" javaType="java.lang.String"/>
<result property="movie_director" column="movie_director" javaType="java.lang.String"/>
<result property="movie_duration" column="movie_duration" javaType="java.lang.String"/>
<result property="movie_fg_name" column="movie_fg_name" javaType="java.lang.String"/>
<result property="movie_picture" column="movie_picture" javaType="java.lang.String"/>
<result property="movie_score" column="movie_score" javaType="float"/>
<result property="movie_type" column="movie_type" javaType="java.lang.String"/>
<result property="movie_releaseDate" column="movie_releaseDate" javaType="java.sql.Date"/>
<result property="movie_state" column="movie_state" javaType="java.lang.Integer"/>
</resultMap>
<select id="findMovieById" parameterType="long" resultMap="BaseResultMap">
select * from movie where movie_id = #{movie_id}
</select>
<select id="findMovieByName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_cn_name = #{movie_cn_name}
</select>
<insert id="addMovie" parameterType="com.entity.Movie">
insert into movie(movie_cn_name,movie_fg_name,movie_actor,movie_director,movie_detail,movie_duration,movie_type,movie_score,movie_releaseDate,movie_country,movie_picture)
values(#{movie_cn_name},#{movie_fg_name},#{movie_actor},#{movie_director},#{movie_detail},#{movie_duration},#{movie_type},#{movie_score},#{movie_releaseDate},#{movie_country},#{movie_picture})
</insert>
<update id="deleteMovie" parameterType="long">
update movie
<set>
movie_state = 0
</set>
where movie_id = #{movie_id}
</update>
<update id="changeMovieBoxOffice">
update movie set movie_boxOffice = movie_boxOffice + #{movie_boxOffice} where movie_id = #{movie_id}
</update>
<update id="updateMovie" parameterType="com.entity.Movie">
update movie
<set>
movie_cn_name = #{movie_cn_name},
movie_fg_name = #{movie_fg_name},
movie_actor = #{movie_actor},
movie_director = #{movie_director},
movie_detail = #{movie_detail},
movie_duration = #{movie_duration},
movie_type = #{movie_type},
movie_country = #{movie_country},
movie_picture = #{movie_picture}
</set>
where movie_id = #{movie_id}
</update>
<update id="deleteMovieCommentCount" parameterType="long">
update movie set movie_commentCount = movie_commentCount -1 where movie_id = #{movie_id}
</update>
<update id="addMovieCommentCount" parameterType="long">
update movie set movie_commentCount = movie_commentCount +1 where movie_id = #{movie_id}
</update>
<select id="findAllMovies" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select * from movie where movie_state = #{movie_state}
</select>
<select id="findMoviesLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_cn_name like '%${value}%' and movie_state = 1
</select>
<select id="findMoviesLikeType" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from movie where movie_type like '%${value}%' and movie_state = 1
</select>
<select id="sortMovieByDate" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_releaseDate DESC
</select>
<select id="sortMovieByCount" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_commentCount DESC
</select>
<select id="sortMovieByScore" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_score DESC
</select>
<select id="sortMovieByBoxOffice" resultMap="BaseResultMap">
select * from movie where movie_state = 1 order by movie_boxOffice desc
</select>
</mapper>

95
src/main/java/com/mapper/OrderMapper.java
Unescape View File

@ -6,89 +6,16 @@ import org.springframework.stereotype.Repository;
import com.entity.Order;
/**
* OrderMapper接口，用于定义针对订单（Order）相关数据进行持久化操作（通常对应数据库操作）的方法签名。
* 该接口一般会由对应的Mapper实现类来具体实现其方法逻辑，从而实现与数据库的交互，例如查询订单信息、插入新订单、更新订单状态以及按不同条件筛选订单等操作，是处理订单数据持久化的重要部分。
* 通过使用`@Repository`注解，将该接口标记为Spring的持久层组件，便于Spring框架进行管理以及依赖注入等操作。
*/
@Repository
public interface OrderMapper {
/**
* 根据订单的唯一标识（ID）查询订单信息的方法签名。
* 对应的实现类中需要编写具体的SQL语句（例如使用MyBatis框架时在对应的XML映射文件中编写SQL）来从数据库中查找指定ID的订单记录，并将其映射为`Order`实体对象返回，方便获取特定订单的详细情况。
* @param order_id 要查询的订单的唯一标识（通常是一个具有特定格式的字符串）
* @return 返回一个`Order`对象，代表查询到的订单信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Order findOrderById(String order_id);
/**
* 向数据库中插入一条新的订单记录的方法签名。
* 实现类中要编写合适的SQL插入语句，将传入的`Order`对象所包含的订单信息（如所属用户编号、场次编号、座位信息等各种属性值）插入到数据库对应的表中，
* 并根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），以此判断订单插入是否成功。
* @param order 包含要插入的订单信息的`Order`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addOrder(Order order);
/**
* 将指定订单的状态更新为申请退票状态的方法签名。
* 实现类需编写SQL更新语句，依据传入的订单唯一标识（order_id），在数据库中找到对应的订单记录，并将其订单状态字段更新为表示申请退票的值（具体值由业务逻辑中约定，例如可能是某个特定的数字代表申请退票状态），
* 然后返回受影响的行数来表明更新操作是否成功执行（一般成功更新返回1，不存在对应记录返回0等情况），用于确认订单状态更新为申请退票这一操作的结果。
* @param order_id 要更新状态为申请退票的订单的唯一标识
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateOrderStateToRefund(String order_id); //申请退票
/**
* 将指定订单的状态更新为同意退票状态的方法签名。
* 对应的实现类要编写SQL更新语句，通过传入的订单唯一标识（order_id）在数据库里定位到相应订单记录，把其订单状态字段更新为表示同意退票的值（按照业务逻辑中定义的相应状态值来更新，比如另一个特定数字表示同意退票），
* 同样根据更新操作结果返回受影响的行数，用于判断订单状态更新为同意退票这一操作是否成功执行。
* @param order_id 要更新状态为同意退票的订单的唯一标识
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateOrderStateToRefunded(String order_id); //同意退票
/**
* 根据用户名查询该用户所有处于申请退票状态的订单信息的方法签名。
* 实现类编写的SQL语句会依据传入的用户名，在数据库中筛选出属于该用户且订单状态为申请退票的所有订单记录，
* 并将每条记录映射为`Order`实体对象，最后以`List<Order>`集合的形式返回这些订单信息列表，方便查看特定用户的申请退票订单情况，便于后续处理退票相关业务。
* @param user_name 要查询其申请退票订单的用户名
* @return 返回一个包含符合条件的`Order`对象的`List`集合，每个对象代表一条申请退票的订单记录信息，可能为空集合（如果该用户没有申请退票的订单）
*/
List<Order> findRefundOrderByUserName(String user_name);
/**
* 根据用户名查询该用户的所有订单信息的方法签名。
* 实现类中编写的SQL语句会按照传入的用户名，从数据库中查找属于该用户的所有订单记录，
* 并将这些记录映射为`Order`实体对象，最后以`List<Order>`集合的形式返回订单信息列表，方便获取特定用户的全部订单情况，可用于用户查看自己的历史订单等业务场景。
* @param user_name 要查询其订单的用户名
* @return 返回一个包含符合条件的`Order`对象的`List`集合，每个对象代表一条该用户的订单记录信息，可能为空集合（如果该用户没有订单记录）
*/
List<Order> findOrdersByUserName(String user_name);
/**
* 查询数据库中所有订单信息的方法签名。
* 对应的实现类应编写SQL查询语句，从数据库表中获取全部的订单记录，并将每条记录映射为`Order`实体对象，最后以`List<Order>`集合的形式返回所有订单信息列表，方便进行整体的订单数据统计、管理等操作。
* @return 返回一个包含所有`Order`对象的`List`集合，每个对象代表一条订单记录信息
*/
List<Order> findAllOrders();
/**
* 根据场次的唯一标识（ID）查询该场次下所有订单信息的方法签名。
* 实现类编写的SQL语句会依据传入的场次ID，在数据库中查找属于该场次的所有订单记录，
* 并将每条记录映射为`Order`实体对象，最后以`List<Order>`集合的形式返回这些订单信息列表，方便获取某个场次对应的所有订单情况，例如统计场次的售票情况等业务场景会用到。
* @param schedule_id 要查询其下订单的场次的唯一标识
* @return 返回一个包含符合条件的`Order`对象的`List`集合，每个对象代表一条该场次的订单记录信息，可能为空集合（如果该场次没有订单记录）
*/
List<Order> findOrdersByScheduleId(long schedule_id);
/**
* 根据订单状态查询所有符合该状态的订单信息的方法签名。
* 实现类需编写SQL语句，按照传入的订单状态值（通常是一个整数表示不同状态，例如1表示已支付，0表示退票中等等，具体依业务定义而定），在数据库中筛选出处于该状态的所有订单记录，
* 并将每条记录映射为`Order`实体对象，最后以`List<Order>`集合的形式返回这些订单信息列表，便于按状态查看订单情况，例如统计不同状态订单的数量等业务操作。
* @param order_state 表示订单状态的整数，用于筛选符合该状态的订单记录
* @return 返回一个包含符合条件的`Order`对象的`List`集合，每个对象代表一条符合该状态的订单记录信息，可能为空集合（如果没有符合该状态的订单）
*/
List<Order> findOrdersByState(int order_state);
}
Order findOrderById(String order_id);
Integer addOrder(Order order);
Integer updateOrderStateToRefund(String order_id); //申请退票
Integer updateOrderStateToRefunded(String order_id); //同意退票
List<Order> findRefundOrderByUserName(String user_name);
List<Order> findOrdersByUserName(String user_name);
List<Order> findAllOrders();
List<Order> findOrdersByScheduleId(long schedule_id);
List<Order> findOrdersByState(int order_state);
}

106
src/main/java/com/mapper/OrderMapper.xml
Unescape View File

@ -2,65 +2,51 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 定义一个名为 OrderMapper 的映射器，与 com.mapper 包下的 OrderMapper 接口相对应 -->
<mapper namespace="com.mapper.OrderMapper">
<!-- 定义一个 resultMap，用于将查询结果映射到 Java 对象 com.entity.Order -->
<resultMap type="com.entity.Order" id="BaseResultMap">
<!-- 指定主键字段 order_id 映射到 Order 类的 order_id 属性 -->
<id property="order_id" column="order_id" javaType="java.lang.String"/>
<!-- 映射其他非主键字段 -->
<result property="order_position" column="order_position" javaType="java.lang.String"/>
<result property="order_state" column="order_state" javaType="java.lang.Integer"/>
<result property="schedule_id" column="schedule_id" javaType="long"/>
<result property="user_id" column="user_id" javaType="long"/>
<result property="order_price" column="order_price" javaType="java.lang.Integer"/>
<result property="order_time" column="order_time" javaType="java.util.Date"/>
</resultMap>
<!-- 根据订单 ID 查询单个订单 -->
<select id="findOrderById" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from orderinfo where order_id = #{order_id}
</select>
<!-- 查询所有订单，并按订单时间降序排列 -->
<select id="findAllOrders" resultMap="BaseResultMap">
select * from orderinfo order by order_time desc
</select>
<!-- 根据日程表 ID 查询订单，排除状态为 2（可能表示已退款）的订单，并按订单时间降序排列 -->
<select id="findOrdersByScheduleId" parameterType="long" resultMap="BaseResultMap">
select * from orderinfo where schedule_id = #{schedule_id} and order_state != 2 order by order_time desc
</select>
<!-- 根据订单状态查询订单，并按订单时间降序排列 -->
<select id="findOrdersByState" parameterType="int" resultMap="BaseResultMap">
select * from orderinfo where order_state = #{order_state} order by order_time desc
</select>
<!-- 根据用户名查询该用户的订单，并按订单时间降序排列 -->
<select id="findOrdersByUserName" parameterType="java.lang.String" resultMap="BaseResultMap">
select orderinfo.* from orderinfo,user where orderinfo.user_id = user.user_id and user.user_name = #{user_name} order by order_time desc
</select>
<!-- 查询特定用户的待退款订单（假设状态 0 表示待退款），并按订单时间降序排列 -->
<select id="findRefundOrderByUserName" parameterType="java.lang.String" resultMap="BaseResultMap">
select orderinfo.* from orderinfo,user where orderinfo.user_id = user.user_id and user.user_name = #{user_name} and orderinfo.order_state = 0 order by order_time desc
</select>
<!-- 插入新订单记录 -->
<insert id="addOrder" parameterType="com.entity.Order">
insert into orderinfo(order_id,order_position,schedule_id,user_id,order_price,order_time)
values(#{order_id},#{order_position},#{schedule_id},#{user_id},#{order_price},#{order_time})
</insert>
<!-- 更新订单状态为待退款（假设状态 0 表示待退款） -->
<update id="updateOrderStateToRefund" parameterType="java.lang.String">
update orderinfo set order_state = 0 where order_id = #{order_id}
</update>
<!-- 更新订单状态为已退款（假设状态 2 表示已退款） -->
<update id="updateOrderStateToRefunded" parameterType="java.lang.String">
update orderinfo set order_state = 2 where order_id = #{order_id}
</update>
<resultMap type="com.entity.Order" id="BaseResultMap">
<id property="order_id" column="order_id" javaType="java.lang.String"/>
<result property="order_position" column="order_position" javaType="java.lang.String"/>
<result property="order_state" column="order_state" javaType="java.lang.Integer"/>
<result property="schedule_id" column="schedule_id" javaType="long"/>
<result property="user_id" column="user_id" javaType="long"/>
<result property="order_price" column="order_price" javaType="java.lang.Integer"/>
<result property="order_time" column="order_time" javaType="java.util.Date"/>
</resultMap>
<select id="findOrderById" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from orderinfo where order_id = #{order_id}
</select>
<select id="findAllOrders" resultMap="BaseResultMap">
select * from orderinfo order by order_time desc
</select>
<select id="findOrdersByScheduleId" parameterType="long" resultMap="BaseResultMap">
select * from orderinfo where schedule_id = #{schedule_id} and order_state != 2 order by order_time desc
</select>
<select id="findOrdersByState" parameterType="int" resultMap="BaseResultMap">
select * from orderinfo where order_state = #{order_state} order by order_time desc
</select>
<select id="findOrdersByUserName" parameterType="java.lang.String" resultMap="BaseResultMap">
select orderinfo.* from orderinfo,user where orderinfo.user_id = user.user_id and user.user_name = #{user_name} order by order_time desc
</select>
<select id="findRefundOrderByUserName" parameterType="java.lang.String" resultMap="BaseResultMap">
select orderinfo.* from orderinfo,user where orderinfo.user_id = user.user_id and user.user_name = #{user_name} and orderinfo.order_state = 0 order by order_time desc
</select>
<insert id="addOrder" parameterType="com.entity.Order">
insert into orderinfo(order_id,order_position,schedule_id,user_id,order_price,order_time)
values(#{order_id},#{order_position},#{schedule_id},#{user_id},#{order_price},#{order_time})
</insert>
<update id="updateOrderStateToRefund" parameterType="java.lang.String">
update orderinfo set order_state = 0 where order_id = #{order_id}
</update>
<update id="updateOrderStateToRefunded" parameterType="java.lang.String">
update orderinfo set order_state = 2 where order_id = #{order_id}
</update>
</mapper>

126
src/main/java/com/mapper/ScheduleMapper.java
Unescape View File

@ -7,118 +7,18 @@ import org.springframework.stereotype.Repository;
import com.entity.Schedule;
/**
* ScheduleMapper接口，用于定义针对电影场次（Schedule）相关数据进行持久化操作（通常对应数据库操作）的方法签名。
* 该接口一般会由对应的Mapper实现类来具体实现其方法逻辑，进而实现与数据库的交互，例如查询、插入、更新、删除场次信息，以及对场次的剩余座位数进行操作，还有按照不同条件（如电影名称、影院、状态等）筛选场次等功能。
* 通过使用`@Repository`注解，将该接口标记为Spring的持久层组件，便于Spring框架进行管理以及依赖注入等操作。
*/
@Repository
public interface ScheduleMapper {
/**
* 根据电影场次的唯一标识（ID）查询该场次信息的方法签名。
* 对应的实现类中需要编写具体的SQL语句（例如使用MyBatis框架时在对应的XML映射文件中编写SQL）来从数据库中查找指定ID的场次记录，并将其映射为`Schedule`实体对象返回，方便获取特定场次的详细情况。
* @param schedule_id 要查询的电影场次的唯一标识
* @return 返回一个`Schedule`对象，代表查询到的场次信息，如果未找到则返回`null`（具体取决于实现逻辑）
*/
Schedule findScheduleById(long schedule_id);
/**
* 向数据库中插入一条新的电影场次记录的方法签名。
* 实现类中要编写合适的SQL插入语句，将传入的`Schedule`对象所包含的场次信息（如所属放映厅、放映的电影编号、放映时间、售价等各种属性值）插入到数据库对应的表中，
* 并根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），以此判断场次信息插入是否成功。
* @param schedule 包含要插入的场次信息的`Schedule`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addSchedule(Schedule schedule);
/**
* 根据传入的`Schedule`对象信息更新数据库中对应的电影场次记录的方法签名。
* 实现类中要编写相应的SQL更新语句，依据`Schedule`对象中的属性值（例如放映时间、售价等属性发生变化时）来更新数据库里对应场次记录的相应字段，
* 同样根据更新操作结果返回受影响的行数，用于判断场次记录更新是否成功执行。
* @param schedule 包含更新后场次信息的`Schedule`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateSchedule(Schedule schedule);
/**
* 根据电影场次的唯一标识（ID）从数据库中删除对应的场次记录的方法签名。
* 实现类需编写SQL删除语句，将指定ID的场次记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况），用于确认场次记录删除操作的结果。
* @param schedule_id 要删除的电影场次的唯一标识
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
Integer deleteSchedule(long schedule_id);
/**
* 增加指定电影场次的剩余座位数的方法签名。
* 实现类需编写SQL语句，针对传入的场次唯一标识（schedule_id），在数据库中找到对应的场次记录，并对其剩余座位数字段进行增加操作（具体增加的值可能在SQL语句中固定设置或者根据业务逻辑动态确定），
* 然后返回受影响的行数来表明操作是否成功执行，常用于例如退票操作后增加场次剩余座位数等业务场景。
* @param schedule_id 要增加剩余座位数的电影场次的唯一标识
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer addScheduleRemain(long schedule_id);
/**
* 减少指定电影场次的剩余座位数的方法签名。
* 对应的实现类要编写SQL语句，依据传入的场次ID（schedule_id）在数据库里定位到相应场次记录，把其剩余座位数字段进行减少操作（减少的值按业务需求设定，比如购票时减少相应数量的座位），
* 同样根据操作结果返回受影响的行数，用于判断减少剩余座位数这一操作是否成功执行，可应用于购票等导致座位数减少的业务场景。
* @param schedule_id 要减少剩余座位数的电影场次的唯一标识
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer delScheduleRemain(long schedule_id);
/**
* 根据电影名称查询所有放映该电影的场次信息的方法签名。
* 实现类编写的SQL语句会依据传入的电影名称，在数据库中筛选出放映该电影的所有场次记录，
* 并将每条记录映射为`Schedule`实体对象，最后以`List<Schedule>`集合的形式返回这些场次信息列表，方便用户查看某部电影的放映场次安排，便于选择合适的场次观影。
* @param movie_name 要查询其放映场次的电影的名称
* @return 返回一个包含符合条件的`Schedule`对象的`List`集合，每个对象代表一条放映该电影的场次记录信息，可能为空集合（如果没有放映该电影的场次）
*/
List<Schedule> findScheduleByMovieName(String movie_name);
/**
* 根据电影名称查询所有已下架的该电影的场次信息的方法签名。
* 实现类需编写SQL语句，按照传入的电影名称，在数据库中查找已处于下架状态（比如场次取消、电影下线等原因导致不再放映）且放映该电影的场次记录，
* 并将每条记录映射为`Schedule`实体对象，最后以`List<Schedule>`集合的形式返回这些场次信息列表，可用于统计已下架场次等相关业务操作。
* @param movie_name 要查询其已下架场次的电影的名称
* @return 返回一个包含符合条件的`Schedule`对象的`List`集合，每个对象代表一条已下架且放映该电影的场次记录信息，可能为空集合（如果没有符合条件的场次）
*/
List<Schedule> findOffScheduleByMovieName(String movie_name);
/**
* 根据场次状态查询所有符合该状态的场次信息的方法签名。
* 实现类编写的SQL语句会按照传入的场次状态值（通常是一个整数表示不同状态，例如1表示上映中，0表示下架等，具体依业务定义而定），在数据库中筛选出处于该状态的所有场次记录，
* 并将每条记录映射为`Schedule`实体对象，最后以`List<Schedule>`集合的形式返回这些场次信息列表，便于按状态查看场次情况，例如展示正在上映的场次列表等业务场景。
* @param schedule_state 表示场次状态的整数，用于筛选符合该状态的场次记录
* @return 返回一个包含符合条件的`Schedule`对象的`List`集合，每个对象代表一条符合该状态的场次记录信息，可能为空集合（如果没有符合该状态的场次）
*/
List<Schedule> findScheduleByState(int schedule_state);
/**
* 查询数据库中所有电影场次信息的方法签名。
* 对应的实现类应编写SQL查询语句，从数据库表中获取全部的场次记录，并将每条记录映射为`Schedule`实体对象，最后以`List<Schedule>`集合的形式返回所有场次信息列表，方便进行整体的场次数据统计、管理等操作。
* @return 返回一个包含所有`Schedule`对象的`List`集合，每个对象代表一条场次记录信息
*/
List<Schedule> findAllSchedule();
/**
* 根据影院的唯一标识（ID）和电影的唯一标识（ID）查询该影院放映该电影的所有场次信息的方法签名。
* 通过`@Param`注解明确了两个参数名，方便在SQL语句中准确引用参数值，实现类编写的SQL语句会依据传入的影院ID和电影ID，在数据库中查找该影院放映指定电影的所有场次记录，
* 并将每条记录映射为`Schedule`实体对象，最后以`List<Schedule>`集合的形式返回这些场次信息列表，方便查看特定影院放映某部电影的具体场次安排，例如用户选择在某影院观看某部电影时查看可选场次。
* @param cinema_id 要查询其放映场次的影院的唯一标识
* @param movie_id 要查询其放映场次的电影的唯一标识
* @return 返回一个包含符合条件的`Schedule`对象的`List`集合，每个对象代表一条该影院放映该电影的场次记录信息，可能为空集合（如果该影院没有放映该电影的场次）
*/
List<Schedule> findScheduleByCinemaAndMovie(@Param("cinema_id") long cinema_id, @Param("movie_id") long movie_id);
/**
* 根据放映厅的唯一标识（ID）、影院的唯一标识（ID）以及电影的唯一标识（ID）查询该放映厅（位于该影院内）放映该电影的所有场次信息的方法签名。
* 借助`@Param`注解指明三个参数名，实现类编写的SQL语句会依据传入的放映厅ID、影院ID和电影ID，在数据库中查找该放映厅（属于指定影院）放映指定电影的所有场次记录，
* 并将每条记录映射为`Schedule`实体对象，最后以`List<Schedule>`集合的形式返回这些场次信息列表，更精准地获取特定放映厅放映某部电影的场次安排情况，例如用户指定具体放映厅查看场次。
* @param hall_id 要查询其放映场次的放映厅的唯一标识
* @param cinema_id 要查询其放映场次的影院的唯一标识
* @param movie_id 要查询其放映场次的电影的唯一标识
* @return 返回一个包含符合条件的`Schedule`对象的`List`集合，每个对象代表一条该放映厅放映该电影的场次记录信息，可能为空集合（如果该放映厅没有放映该电影的场次）
*/
List<Schedule> findScheduleByCinemaAndMovieAndHall(@Param("hall_id") long hall_id, @Param("cinema_id") long cinema_id, @Param("movie_id") long movie_id);
}
Schedule findScheduleById(long schedule_id);
Integer addSchedule(Schedule schedule);
Integer updateSchedule(Schedule schedule);
Integer deleteSchedule(long schedule_id);
Integer addScheduleRemain(long schedule_id);
Integer delScheduleRemain(long schedule_id);
List<Schedule> findScheduleByMovieName(String movie_name);
List<Schedule> findOffScheduleByMovieName(String movie_name);
List<Schedule> findScheduleByState(int schedule_state);
List<Schedule> findAllSchedule();
List<Schedule> findScheduleByCinemaAndMovie(@Param("cinema_id")long cinema_id,@Param("movie_id")long movie_id);
List<Schedule> findScheduleByCinemaAndMovieAndHall(@Param("hall_id")long hall_id,@Param("cinema_id")long cinema_id,@Param("movie_id")long movie_id);
}

149
src/main/java/com/mapper/ScheduleMapper.xml
Unescape View File

@ -2,88 +2,71 @@
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 定义一个名为 ScheduleMapper 的映射器，与 com.mapper 包下的 ScheduleMapper 接口相对应 -->
<mapper namespace="com.mapper.ScheduleMapper">
<!-- 定义一个 resultMap，用于将查询结果映射到 Java 对象 com.entity.Schedule -->
<resultMap type="com.entity.Schedule" id="BaseResultMap">
<!-- 指定主键字段 schedule_id 映射到 Schedule 类的 schedule_id 属性 -->
<id property="schedule_id" column="schedule_id" javaType="long"/>
<!-- 映射其他非主键字段 -->
<result property="hall_id" column="hall_id" javaType="long"/>
<result property="movie_id" column="movie_id" javaType="long"/>
<result property="schedule_price" column="schedule_price" javaType="java.lang.Integer"/>
<result property="schedule_remain" column="schedule_remain" javaType="java.lang.Integer"/>
<result property="schedule_startTime" column="schedule_startTime" javaType="java.lang.String"/>
<result property="schedule_state" column="schedule_state" javaType="java.lang.Integer"/>
</resultMap>
<!-- 根据日程表 ID 查询单个日程表信息 -->
<select id="findScheduleById" parameterType="long" resultMap="BaseResultMap">
select * from schedule where schedule_id = #{schedule_id}
</select>
<!-- 根据日程表状态查询日程表信息 -->
<select id="findScheduleByState" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select * from schedule where schedule_state = #{schedule_state}
</select>
<!-- 根据影院 ID 和电影 ID 查询日程表信息，仅包括状态为 1（可能表示正在上映）的日程表 -->
<select id="findScheduleByCinemaAndMovie" resultMap="BaseResultMap">
select schedule.* from schedule,hall where schedule.hall_id=hall.hall_id
and hall.cinema_id = #{cinema_id} and movie_id = #{movie_id} and schedule_state = 1
</select>
<!-- 根据影院 ID、电影 ID 和影厅 ID 查询日程表信息，仅包括状态为 1（可能表示正在上映）的日程表 -->
<select id="findScheduleByCinemaAndMovieAndHall" resultMap="BaseResultMap">
select schedule.* from schedule,hall where schedule.hall_id=hall.hall_id
and hall.cinema_id = #{cinema_id} and movie_id = #{movie_id} and schedule.hall_id = #{hall_id} and schedule_state = 1
</select>
<!-- 查询所有日程表信息 -->
<select id="findAllSchedule" resultMap="BaseResultMap">
select * from schedule
</select>
<!-- 根据电影中文名称模糊查询日程表信息，仅包括状态为 1（可能表示正在上映）的日程表 -->
<select id="findScheduleByMovieName" parameterType="java.lang.String" resultMap="BaseResultMap">
select schedule.* from schedule,movie
where schedule.movie_id = movie.movie_id and schedule.schedule_state = 1 and movie.movie_cn_name like '%${value}%'
</select>
<!-- 根据电影中文名称模糊查询已下线的日程表信息，仅包括状态为 0（可能表示已下线）的日程表 -->
<select id="findOffScheduleByMovieName" parameterType="java.lang.String" resultMap="BaseResultMap">
select schedule.* from schedule,movie
where schedule.movie_id = movie.movie_id and schedule.schedule_state = 0 and movie.movie_cn_name like '%${value}%'
</select>
<!-- 插入新的日程表记录 -->
<insert id="addSchedule" parameterType="com.entity.Schedule">
insert into schedule(hall_id,movie_id,schedule_price,schedule_remain,schedule_startTime)
values(#{hall_id},#{movie_id},#{schedule_price},#{schedule_remain},#{schedule_startTime})
</insert>
<!-- 更新日程表的价格 -->
<update id="updateSchedule" parameterType="com.entity.Schedule">
update schedule
<set>
schedule_price = #{schedule_price}
</set>
where schedule_id = #{schedule_id}
</update>
<!-- 将日程表的状态设置为 0（可能表示下线），实际上是一种逻辑删除 -->
<update id="deleteSchedule" parameterType="long">
update schedule set schedule_state = 0 where schedule_id = #{schedule_id}
</update>
<!-- 增加日程表的剩余座位数 -->
<update id="addScheduleRemain" parameterType="long">
update schedule set schedule_remain = schedule_remain + 1 where schedule_id = #{schedule_id}
</update>
<!-- 减少日程表的剩余座位数 -->
<update id="delScheduleRemain" parameterType="long">
update schedule set schedule_remain = schedule_remain - 1 where schedule_id = #{schedule_id}
</update>
<resultMap type="com.entity.Schedule" id="BaseResultMap">
<id property="schedule_id" column="schedule_id" javaType="long"/>
<result property="hall_id" column="hall_id" javaType="long"/>
<result property="movie_id" column="movie_id" javaType="long"/>
<result property="schedule_price" column="schedule_price" javaType="java.lang.Integer"/>
<result property="schedule_remain" column="schedule_remain" javaType="java.lang.Integer"/>
<result property="schedule_startTime" column="schedule_startTime" javaType="java.lang.String"/>
<result property="schedule_state" column="schedule_state" javaType="java.lang.Integer"/>
</resultMap>
<select id="findScheduleById" parameterType="long" resultMap="BaseResultMap">
select * from schedule where schedule_id = #{schedule_id}
</select>
<select id="findScheduleByState" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select * from schedule where schedule_state = #{schedule_state}
</select>
<select id="findScheduleByCinemaAndMovie" resultMap="BaseResultMap">
select schedule.* from schedule,hall where schedule.hall_id=hall.hall_id
and hall.cinema_id = #{cinema_id} and movie_id = #{movie_id} and schedule_state = 1
</select>
<select id="findScheduleByCinemaAndMovieAndHall" resultMap="BaseResultMap">
select schedule.* from schedule,hall where schedule.hall_id=hall.hall_id
and hall.cinema_id = #{cinema_id} and movie_id = #{movie_id} and schedule.hall_id = #{hall_id} and schedule_state = 1
</select>
<select id="findAllSchedule" resultMap="BaseResultMap">
select * from schedule
</select>
<select id="findScheduleByMovieName" parameterType="java.lang.String" resultMap="BaseResultMap">
select schedule.* from schedule,movie
where schedule.movie_id = movie.movie_id and schedule.schedule_state = 1 and movie.movie_cn_name like '%${value}%'
</select>
<select id="findOffScheduleByMovieName" parameterType="java.lang.String" resultMap="BaseResultMap">
select schedule.* from schedule,movie
where schedule.movie_id = movie.movie_id and schedule.schedule_state = 0 and movie.movie_cn_name like '%${value}%'
</select>
<insert id="addSchedule" parameterType="com.entity.Schedule">
insert into schedule(hall_id,movie_id,schedule_price,schedule_remain,schedule_startTime)
values(#{hall_id},#{movie_id},#{schedule_price},#{schedule_remain},#{schedule_startTime})
</insert>
<update id="updateSchedule" parameterType="com.entity.Schedule">
update schedule
<set>
schedule_price = #{schedule_price}
</set>
where schedule_id = #{schedule_id}
</update>
<update id="deleteSchedule" parameterType="long">
update schedule set schedule_state = 0 where schedule_id = #{schedule_id}
</update>
<update id="addScheduleRemain" parameterType="long">
update schedule set schedule_remain = schedule_remain + 1 where schedule_id = #{schedule_id}
</update>
<update id="delScheduleRemain" parameterType="long">
update schedule set schedule_remain = schedule_remain - 1 where schedule_id = #{schedule_id}
</update>
</mapper>

68
src/main/java/com/mapper/UserMapper.java
Unescape View File

@ -5,65 +5,13 @@ import java.util.List;
import org.springframework.stereotype.Repository;
import com.entity.User;
/**
* 用户数据访问对象（DAO）接口，用于定义与用户相关的数据库操作。
*/
@Repository
public interface UserMapper {
/**
* 根据用户 ID 查询单个用户信息。
*
* @param user_id 要查询的用户的 ID
* @return 返回匹配的用户实体对象；如果未找到，则返回 null
*/
User findUserById(long user_id);
/**
* 添加新用户到数据库。
*
* @param user 要添加的用户实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer addUser(User user);
/**
* 从数据库中删除指定 ID 的用户。
*
* @param user_id 要删除的用户的 ID
* @return 如果删除成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer deleteUser(long user_id);
/**
* 更新数据库中指定 ID 的用户信息。
*
* @param user 包含更新信息的用户实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer updateUser(User user);
/**
* 查询所有用户信息。
*
* @return 返回包含所有用户实体对象的列表；如果没有用户，则返回空列表
*/
List<User> findAllUser();
/**
* 根据用户名精确查询用户信息。
*
* @param name 要查询的用户名
* @return 返回匹配用户名的用户实体对象列表；如果没有匹配的用户，则返回空列表
*/
List<User> findUserByName(String name);
/**
* 根据用户名模糊查询用户信息。
*
* @param name 包含要查询的关键字的用户名
* @return 返回用户名包含关键字的用户实体对象列表；如果没有匹配的用户，则返回空列表
*/
List<User> findUserLikeName(String name);
}
User findUserById(long user_id);
Integer addUser(User user);
Integer deleteUser(long user_id);
Integer updateUser(User user);
List<User> findAllUser();
List<User> findUserByName(String name);
List<User> findUserLikeName(String name);
}

107
src/main/java/com/mapper/UserMapper.xml
Unescape View File

@ -1,71 +1,44 @@
<?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">
<!-- 此 XML 文件为 MyBatis 的映射文件，用于定义与数据库交互的 SQL 语句以及结果集映射关系等配置内容，其对应的接口是 com.mapper.UserMapper，主要负责处理用户（User）相关的数据操作。 -->
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.UserMapper">
<!-- 定义名为 BaseResultMap 的结果集映射，用于将从数据库查询返回的结果（按照列的形式）映射到 com.entity.User 实体类对应的属性上，方便 MyBatis 将数据库记录转换为 Java 对象，便于后续在程序中使用。 -->
<resultMap type="com.entity.User" id="BaseResultMap">
<!-- 将数据库表 user 中的 user_id 列的值映射到 User 实体类的 user_id 属性上，属性类型为 long -->
<id property="user_id" column="user_id" javaType="long"/>
<!-- 将数据库表 user 中的 user_name 列的值映射到 User 实体类的 user_name 属性上，属性类型为 java.lang.String -->
<result property="user_name" column="user_name" javaType="java.lang.String"/>
<!-- 将数据库表 user 中的 user_pwd 列的值映射到 User 实体类的 user_pwd 属性上，属性类型为 java.lang.String -->
<result property="user_pwd" column="user_pwd" javaType="java.lang.String"/>
<!-- 将数据库表 user 中的 user_email 列的值映射到 User 实体类的 user_email 属性上，属性类型为 java.lang.String -->
<result property="user_email" column="user_email" javaType="java.lang.String"/>
<!-- 将数据库表 user 中的 user_role 列的值映射到 User 实体类的 user_role 属性上，属性类型为 java.lang.Integer -->
<result property="user_role" column="user_role" javaType="java.lang.Integer"/>
<!-- 将数据库表 user 中的 user_headImg 列的值映射到 User 实体类的 user_headImg 属性上，属性类型为 java.lang.String -->
<result property="user_headImg" column="user_headImg" javaType="java.lang.String"/>
</resultMap>
<!-- 定义名为 findUserById 的查询语句，用于根据用户的唯一标识（ID）从 user 表中查询对应的用户信息。
参数类型为 long，表示传入的参数是一个长整型的用户 ID，查询结果通过 BaseResultMap 定义的映射关系转换为 User 实体对象返回。 -->
<select id="findUserById" parameterType="long" resultMap="BaseResultMap">
select * from user where user_id = #{id}
</select>
<!-- 定义名为 findAllUser 的查询语句，用于从 user 表中查询所有的用户信息。
查询结果通过 BaseResultMap 定义的映射关系转换为 User 实体对象，并以列表形式返回所有用户记录对应的 User 对象集合。 -->
<select id="findAllUser" resultMap="BaseResultMap">
select * from user
</select>
<!-- 定义名为 findUserByName 的查询语句，用于根据用户的名称（通常为用户名）从 user 表中查询对应的用户信息。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的用户名，查询结果通过 BaseResultMap 定义的映射关系转换为 User 实体对象返回。 -->
<select id="findUserByName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from user where user_name = #{name}
</select>
<!-- 定义名为 findUserLikeName 的查询语句，用于根据用户名称进行模糊查询。
参数类型为 java.lang.String，表示传入的参数是一个字符串类型的用户名称，通过使用 LIKE 关键字结合通配符 '%${value}%'（此处使用 ${} 是为了直接将传入的字符串拼接进 SQL 语句实现模糊匹配，需注意防止 SQL 注入问题），在 user 表中查找名称符合模糊匹配条件的用户记录，查询结果通过 BaseResultMap 映射为 User 实体对象并返回对应的用户集合，常用于用户搜索等功能实现。 -->
<select id="findUserLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from user where user_name like '%${value}%'
</select>
<!-- 定义名为 addUser 的插入语句，用于向 user 表中插入一条新的用户记录。
参数类型为 com.entity.User，表示传入的参数是一个 User 实体对象，从该对象中获取 user_name、user_pwd 和 user_email 等属性值，插入到 user 表对应的列中，实现新增用户记录的操作。注意这里插入时未包含 user_role 和 user_headImg 字段，可能在业务逻辑中有默认值设置或者后续更新等操作来完善这两个字段的值。 -->
<insert id="addUser" parameterType="com.entity.User">
insert into user(user_name,user_pwd,user_email)
values(#{user_name},#{user_pwd},#{user_email})
</insert>
<!-- 定义名为 updateUser 的更新语句，用于更新 user 表中指定用户记录的部分信息。
参数类型为 com.entity.User，表示传入的参数是一个 User 实体对象，通过 <if> 标签进行条件判断，当传入对象的 user_name 属性不为空时，才会将对应的 user_name 列值更新为传入对象的 user_name 属性值；同理，当 user_pwd 属性不为空时更新 user_pwd 列的值；而 user_email 和 user_headImg 列无论对应属性值是否为空都会进行更新（此处的逻辑可根据业务需求调整），更新条件是 user_id 列的值与传入对象的 user_id 属性值相等，通过 <set> 标签来动态生成需要更新的列，避免不必要的列更新为空值等情况。 -->
<update id="findUserById" parameterType="com.entity.User">
update user
<set>
<if test="user_name!=null">
user_name = #{user_name},
</if>
<if test="user_pwd!=null">
user_pwd = #{user_pwd},
</if>
user_email = #{user_email},
user_headImg = #{user_headImg}
</set>
where user_id = #{user_id}
</update>
<resultMap type="com.entity.User" id="BaseResultMap">
<id property="user_id" column="user_id" javaType="long"/>
<result property="user_name" column="user_name" javaType="java.lang.String"/>
<result property="user_pwd" column="user_pwd" javaType="java.lang.String"/>
<result property="user_email" column="user_email" javaType="java.lang.String"/>
<result property="user_role" column="user_role" javaType="java.lang.Integer"/>
<result property="user_headImg" column="user_headImg" javaType="java.lang.String"/>
</resultMap>
<select id="findUserById" parameterType="long" resultMap="BaseResultMap">
select * from user where user_id = #{id}
</select>
<select id="findAllUser" resultMap="BaseResultMap">
select * from user
</select>
<select id="findUserByName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from user where user_name = #{name}
</select>
<select id="findUserLikeName" parameterType="java.lang.String" resultMap="BaseResultMap">
select * from user where user_name like '%${value}%'
</select>
<insert id="addUser" parameterType="com.entity.User">
insert into user(user_name,user_pwd,user_email)
values(#{user_name},#{user_pwd},#{user_email})
</insert>
<update id="updateUser" parameterType="com.entity.User">
update user
<set>
<if test="user_name!=null">
user_name = #{user_name},
</if>
<if test="user_pwd!=null">
user_pwd = #{user_pwd},
</if>
user_email = #{user_email},
user_headImg = #{user_headImg}
</set>
where user_id = #{user_id}
</update>
</mapper>

70
src/main/java/com/service/ICinemaService.java
Unescape View File

@ -4,66 +4,12 @@ import java.util.List;
import com.entity.Cinema;
/**
* ICinemaService接口，用于定义与电影院（Cinema）相关的业务逻辑方法的规范。
* 该接口规定了一系列对电影院数据进行操作的抽象方法，这些方法一般会由具体的实现类来实现其具体的业务逻辑，实现类通常会与数据持久层进行交互（例如调用对应的Mapper层方法），从而完成如查询、添加、更新、删除电影院信息以及按照不同条件筛选电影院等功能，为整个项目中涉及电影院相关业务的模块提供统一的服务调用接口。
*/
public interface ICinemaService {
/**
* 根据电影院的唯一标识（ID）查询对应的电影院信息的方法签名。
* 具体实现类需要编写逻辑（通常是调用数据持久层相关方法与数据库交互），依据传入的电影院ID从数据库中查找对应的电影院记录，并将其转换为`Cinema`实体对象返回，方便获取特定电影院的详细情况，例如电影院名称、地址、联系方式等信息。
* @param cinema_id 要查询的电影院的唯一标识（通常是一个具有特定格式的数字）
* @return 返回一个`Cinema`对象，代表查询到的电影院信息，如果未找到对应的电影院则返回`null`（具体取决于实现逻辑）
*/
Cinema findCinemaById(long cinema_id);
/**
* 向数据库中插入一条新的电影院记录的方法签名。
* 对应的实现类需要实现将传入的包含电影院信息的`Cinema`对象（包含电影院的各种属性，如名称、地址、影厅数量等）插入到数据库的电影院表中的逻辑，并且根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），以此判断电影院信息插入是否成功。
* @param cinema 包含要插入的电影院信息的`Cinema`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addCinema(Cinema cinema);
/**
* 根据传入的`Cinema`对象信息更新数据库中对应的电影院记录的方法签名。
* 实现类要编写代码逻辑，依据传入的`Cinema`对象中的属性值（例如电影院名称、地址等属性发生变化时）来更新数据库里对应电影院记录的相应字段，然后返回受影响的行数，用于判断电影院记录更新是否成功执行。
* @param cinema 包含更新后电影院信息的`Cinema`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateCinema(Cinema cinema);
/**
* 根据电影院的唯一标识（ID）从数据库中删除对应的电影院记录的方法签名。
* 具体实现类需编写逻辑，调用相应的数据持久层方法将指定ID的电影院记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况），用于确认电影院记录删除操作的结果。
* @param cinema_id 要删除的电影院的唯一标识
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
Integer deleteCinema(long cinema_id);
/**
* 查询数据库中所有电影院信息的方法签名。
* 对应的实现类应编写逻辑，通过调用数据持久层相关方法从数据库表中获取全部的电影院记录，并将每条记录转换为`Cinema`实体对象，最后以`List<Cinema>`集合的形式返回所有电影院信息列表，方便进行整体的电影院数据统计、管理等操作，例如展示所有电影院列表供用户选择等业务场景。
* @return 返回一个包含所有`Cinema`对象的`List`集合，每个对象代表一条电影院记录信息
*/
List<Cinema> findAllCinemas();
/**
* 根据电影院名称进行模糊查询，获取符合模糊条件的电影院信息列表的方法签名。
* 实现类需要编写逻辑，依据传入的电影院名称（可以是部分名称等模糊条件），在数据库中查找名称符合模糊匹配条件的电影院记录，
* 并将每条记录转换为`Cinema`实体对象，最后以`List<Cinema>`集合的形式返回这些电影院信息列表，方便用户根据部分名称等模糊信息查找感兴趣的电影院，例如在搜索功能中使用。
* @param cinema_name 要进行模糊查询的电影院名称，用于筛选符合条件的电影院记录
* @return 返回一个包含符合模糊查询条件的`Cinema`对象的`List`集合，可能为空集合（如果没有找到符合条件的电影院）
*/
List<Cinema> findCinemasLikeName(String cinema_name);
/**
* 根据电影的唯一标识（ID）查询放映该电影的所有电影院信息的方法签名。
* 实现类需要编写相应的逻辑，依据传入的电影ID，在数据库中查找放映该电影的所有电影院记录（通常涉及多表关联查询等操作，例如关联场次表、电影院表等），
* 并将每条记录转换为`Cinema`实体对象，最后以`List<Cinema>`集合的形式返回这些电影院信息列表，便于用户查看哪些电影院正在放映指定的电影，方便用户选择观影地点等业务场景。
* @param movie_id 要查询其放映电影院的电影的唯一标识（通常是一个具有特定格式的数字）
* @return 返回一个包含符合条件的`Cinema`对象的`List`集合，每个对象代表一条放映该电影的电影院记录信息，可能为空集合（如果没有电影院放映该电影）
*/
List<Cinema> findCinemasByMovieId(long movie_id);
}
Cinema findCinemaById(long cinema_id);
Integer addCinema(Cinema cinema);
Integer updateCinema(Cinema cinema);
Integer deleteCinema(long cinema_id);
List<Cinema> findAllCinemas();
List<Cinema> findCinemasLikeName(String cinema_name);
List<Cinema> findCinemasByMovieId(long movie_id);
}

80
src/main/java/com/service/ICommentService.java
Unescape View File

@ -5,75 +5,13 @@ import java.util.List;
import com.entity.Comment;
import com.github.pagehelper.PageInfo;
/**
* ICommentService 是评论服务层的接口，定义了与评论相关的业务逻辑操作。
*/
public interface ICommentService {
/**
* 根据评论 ID 查询单条评论信息。
*
* @param comment_id 要查询的评论 ID
* @return 返回包含评论信息的 Comment 实体对象；如果未找到，则返回 null
*/
Comment findCommentById(long comment_id);
/**
* 添加新的评论信息到数据库。
*
* @param comment 包含要添加的评论信息的 Comment 实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer addComemnt(Comment comment);
/**
* 更新指定 ID 的评论信息。
*
* @param comment 包含更新信息的 Comment 实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer updateComment(Comment comment);
/**
* 从数据库中删除指定 ID 的评论信息。
*
* @param comment_id 要删除的评论 ID
* @return 如果删除成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer deleteComment(long comment_id);
/**
* 查询所有评论信息。
*
* @return 返回包含所有评论的 Comment 实体对象列表
*/
List<Comment> findAllComments();
/**
* 根据电影 ID 查询该电影的所有评论信息。
*
* @param movie_id 要查询的电影 ID
* @return 返回包含该电影所有评论的 Comment 实体对象列表
*/
List<Comment> findCommentsByMovieId(long movie_id);
/**
* 分页查询所有评论信息，并支持关键词搜索。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param keyword 搜索关键词，可以是评论内容的一部分
* @return 返回包含分页信息和评论列表的 PageInfo 对象
*/
PageInfo<Comment> findAllCommentsBySplitPage(Integer page, Integer limit, String keyword);
/**
* 分页查询特定用户名下的所有评论信息。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param user_name 用户名
* @return 返回包含分页信息和评论列表的 PageInfo 对象
*/
PageInfo<Comment> findCommentsByUserName(Integer page, Integer limit, String user_name);
}
Comment findCommentById(long comment_id);
Integer addComemnt(Comment comment);
Integer updateComment(Comment comment);
Integer deleteComment(long comment_id);
List<Comment> findAllComments();
List<Comment> findCommentsByMovieId(long movie_id);
PageInfo<Comment> findAllCommentsBySplitPage(Integer page,Integer limit,String keyword);
PageInfo<Comment> findCommentsByUserName(Integer page,Integer limit,String user_name);
}

69
src/main/java/com/service/IHallService.java
Unescape View File

@ -1,66 +1,15 @@
package com.service;
import java.util.List;
import com.entity.Hall;
/**
* IHallService 是影厅服务层的接口，定义了与影厅相关的业务逻辑操作。
*/
public interface IHallService {
/**
* 根据影厅 ID 查询单个影厅信息。
*
* @param hall_id 要查询的影厅 ID
* @return 返回包含影厅信息的 Hall 实体对象；如果未找到，则返回 null
*/
Hall findHallById(long hall_id);
/**
* 根据影院名称和影厅名称查询单个影厅信息。
*
* @param cinema_name 影院名称
* @param hall_name 影厅名称
* @return 返回匹配的 Hall 实体对象；如果未找到，则返回 null
*/
Hall findHallByCinemaAndHallName(String cinema_name, String hall_name);
/**
* 添加新的影厅信息到数据库。
*
* @param hall 包含要添加的影厅信息的 Hall 实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer addHall(Hall hall);
/**
* 更新指定 ID 的影厅信息。
*
* @param hall 包含更新信息的 Hall 实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer updateHall(Hall hall);
/**
* 从数据库中删除指定 ID 的影厅信息。
*
* @param hall_id 要删除的影厅 ID
* @return 如果删除成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer deleteHall(long hall_id);
/**
* 根据影院 ID 查询该影院的所有影厅信息。
*
* @param cinema_id 要查询的影院 ID
* @return 返回包含该影院所有影厅的 Hall 实体对象列表
*/
List<Hall> findHallByCinemaId(long cinema_id);
/**
* 查询所有影厅信息。
*
* @return 返回包含所有影厅的 Hall 实体对象列表
*/
List<Hall> findAllHalls();
}
Hall findHallById(long hall_id);
Hall findHallByCinemaAndHallName(String cinema_name,String hall_name);
Integer addHall(Hall hall);
Integer updateHall(Hall hall);
Integer deleteHall(long hall_id);
List<Hall> findHallByCinemaId(long cinema_id);
List<Hall> findAllHalls();
}

147
src/main/java/com/service/IMovieService.java
Unescape View File

@ -4,134 +4,21 @@ import java.util.List;
import com.entity.Movie;
/**
* IMovieService接口，用于定义一系列针对电影（Movie）相关业务逻辑操作的方法规范。
* 该接口规定了如查询电影详情、添加、删除、更新电影信息，以及对电影的评论数量、票房等相关属性进行操作，还有按照不同条件（如名称、类型、上映时间、评分等）筛选和排序电影等功能的抽象方法，通常会由具体的实现类来实现这些方法的具体业务逻辑，实现类一般会与数据持久层交互来完成相应的数据操作，为项目中涉及电影相关业务的各个模块提供统一的服务调用接口。
*/
public interface IMovieService {
/**
* 根据电影的唯一标识（ID）查询对应的电影信息的方法签名。
* 具体实现类需要编写逻辑（通常是调用数据持久层相关方法与数据库交互），依据传入的电影ID从数据库中查找对应的电影记录，并将其转换为`Movie`实体对象返回，方便获取特定电影的详细情况，例如电影名称、类型、导演、主演、上映时间等信息。
* @param movie_id 要查询的电影的唯一标识（通常是一个具有特定格式的数字）
* @return 返回一个`Movie`对象，代表查询到的电影信息，如果未找到对应的电影则返回`null`（具体取决于实现逻辑）
*/
Movie findMovieById(long movie_id);
/**
* 根据电影的中文名称查询对应的电影信息的方法签名。
* 实现类需编写相应逻辑，按照传入的电影中文名称，在数据库中查找匹配的电影记录，并将其转换为`Movie`实体对象返回，方便通过电影名称来获取其详细信息，便于用户在知道电影名称的情况下查找特定电影，例如用户搜索想看的电影时使用。
* @param movie_cn_name 要查询的电影的中文名称，用于在数据库中筛选对应的电影记录
* @return 返回一个`Movie`对象，代表查询到的电影信息，如果未找到对应的电影则返回`null`（具体取决于实现逻辑）
*/
Movie findMovieByName(String movie_cn_name);
/**
* 向数据库中插入一条新的电影记录的方法签名。
* 对应的实现类需要实现将传入的包含电影信息的`Movie`对象（包含电影的各种属性，如名称、类型、导演、主演、上映时间等）插入到数据库的电影表中的逻辑，并且根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），以此判断电影信息插入是否成功。
* @param movie 包含要插入的电影信息的`Movie`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addMovie(Movie movie);
/**
* 根据电影的唯一标识（ID）从数据库中删除对应的电影记录的方法签名。
* 具体实现类需编写逻辑，调用相应的数据持久层方法将指定ID的电影记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况），用于确认电影记录删除操作的结果。
* @param movie_id 要删除的电影的唯一标识
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
Integer deleteMovie(long movie_id);
/**
* 根据传入的`Movie`对象信息更新数据库中对应的电影记录的方法签名。
* 实现类要编写代码逻辑，依据传入的`Movie`对象中的属性值（例如电影名称、类型、导演等属性发生变化时）来更新数据库里对应电影记录的相应字段，然后返回受影响的行数，用于判断电影记录更新是否成功执行。
* @param movie 包含更新后电影信息的`Movie`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateMovie(Movie movie);
/**
* 根据电影的唯一标识（ID）减少该电影的评论数量的方法签名。
* 实现类需要编写相应逻辑，例如在数据库中找到对应电影记录，对其评论数量字段进行减1等相应减少操作（具体减少的数值及实现方式依业务需求而定），然后返回受影响的行数，用于判断评论数量减少操作是否成功执行，可能用于如删除评论等相关业务场景导致评论数量变化时调用。
* @param movie_id 要减少评论数量的电影的唯一标识
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer delCommentCount(long movie_id);
/**
* 根据传入的价格值更新电影的票房数据的方法签名。
* 实现类需编写逻辑，按照传入的价格（通常表示票房的增加量等，具体含义依业务定义）以及电影ID，在数据库中找到对应的电影记录，对其票房字段进行相应更新（例如增加传入的价格数值等操作），然后返回受影响的行数，用于判断票房数据更新操作是否成功执行，可用于记录电影票房变化情况，如购票成功后增加票房等业务场景。
* @param price 用于更新票房的价格数值，一般表示票房的变化量（增加或减少量，具体依业务而定）
* @param movie_id 要更新票房数据的电影的唯一标识
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer changeMovieBoxOffice(float price, long movie_id);
/**
* 根据电影的唯一标识（ID）增加该电影的评论数量的方法签名。
* 实现类要编写逻辑，在数据库中找到对应电影记录，对其评论数量字段进行加1等相应增加操作（具体增加的数值及实现方式依业务需求而定），然后返回受影响的行数，用于判断评论数量增加操作是否成功执行，可能用于如新增评论等相关业务场景导致评论数量变化时调用。
* @param movie_id 要增加评论数量的电影的唯一标识
* @return 返回一个`Integer`类型的值，表示操作影响的行数，可用于判断操作是否成功
*/
Integer addCommentCount(long movie_id);
/**
* 根据电影状态查询所有符合该状态的电影信息的方法签名。
* 实现类需要编写逻辑，依据传入的电影状态值（通常是一个整数表示不同状态，例如1表示上映中，0表示下架等，具体依业务定义而定），在数据库中筛选出处于该状态的所有电影记录，
* 并将每条记录转换为`Movie`实体对象，最后以`List<Movie>`集合的形式返回这些电影信息列表，便于按状态查看电影情况，例如展示正在上映的电影列表等业务场景。
* @param movie_state 表示电影状态的整数，用于筛选符合该状态的电影记录
* @return 返回一个包含符合条件的`Movie`对象的`List`集合，每个对象代表一条符合该状态的电影记录信息，可能为空集合（如果没有符合该状态的电影）
*/
List<Movie> findAllMovies(int movie_state);
/**
* 根据电影名称进行模糊查询，获取符合模糊条件的电影信息列表的方法签名。
* 实现类需要编写逻辑，依据传入的电影名称（可以是部分名称等模糊条件），在数据库中查找名称符合模糊匹配条件的电影记录，
* 并将每条记录转换为`Movie`实体对象，最后以`List<Movie>`集合的形式返回这些电影信息列表，方便用户根据部分名称等模糊信息查找感兴趣的电影，例如在搜索功能中使用。
* @param name 要进行模糊查询的电影名称，用于筛选符合条件的电影记录
* @return 返回一个包含符合模糊查询条件的`Movie`对象的`List`集合，可能为空集合（如果没有找到符合条件的电影）
*/
List<Movie> findMoviesLikeName(String name);
/**
* 根据电影类型进行模糊查询，获取符合模糊条件的电影信息列表的方法签名。
* 实现类需要编写逻辑，依据传入的电影类型（可以是部分类型关键词等模糊条件），在数据库中查找类型符合模糊匹配条件的电影记录，
* 并将每条记录转换为`Movie`实体对象，最后以`List<Movie>`集合的形式返回这些电影信息列表，方便用户根据电影类型的模糊信息查找感兴趣的电影，例如用户想查找某类题材的电影时使用。
* @param type 要进行模糊查询的电影类型，用于筛选符合条件的电影记录
* @return 返回一个包含符合模糊查询条件的`Movie`对象的`List`集合，可能为空集合（如果没有找到符合条件的电影）
*/
List<Movie> findMoviesLikeType(String type);
/**
* 根据电影的上映时间对电影进行排序，并返回排序后的电影信息列表的方法签名。
* 实现类需要编写相应的排序逻辑（通常涉及从数据库中获取电影记录并按照上映时间字段进行排序操作，例如使用数据库的排序语句或者在代码中对获取到的列表进行排序处理等），
* 最后以`List<Movie>`集合的形式返回排序后的电影信息列表，方便按照上映时间先后展示电影，例如展示近期上映的电影列表等业务场景。
* 这里的排序顺序（升序或降序）依业务需求而定，一般可以是按时间从早到晚或者从晚到早排序，具体实现中会明确排序规则。
* @return 返回一个包含`Movie`对象的`List`集合，代表排序后的电影记录信息，列表顺序依据上映时间排序规则确定
*/
List<Movie> sortMovieByDate();
/**
* 根据电影的参评人数对电影进行排序，并返回排序后的电影信息列表的方法签名。
* 实现类要编写排序逻辑，从数据库中获取电影记录并按照参评人数字段进行排序（升序或降序依业务需求而定，例如按参评人数从多到少或者从少到多排序），
* 最后以`List<Movie>`集合的形式返回排序后的电影信息列表，便于按照参评人数展示电影情况，例如展示热门程度（参评人数多可视为较热门）不同的电影列表等业务场景。
* @return 返回一个包含`Movie`对象的`List`集合，代表排序后的电影记录信息，列表顺序依据参评人数排序规则确定
*/
List<Movie> sortMovieByCount();
/**
* 根据电影的评分对电影进行排序，并返回排序后的电影信息列表的方法签名。
* 实现类需编写排序逻辑，获取电影记录并按照评分字段进行排序（通常可以是按评分从高到低或者从低到高排序，具体依业务需求而定），
* 最后以`List<Movie>`集合的形式返回排序后的电影信息列表，方便按照评分高低展示电影情况，例如推荐高分电影等业务场景。
* @return 返回一个包含`Movie`对象的`List`集合，代表排序后的电影记录信息，列表顺序依据评分排序规则确定
*/
List<Movie> sortMovieByScore();
/**
* 根据电影的票房数据对电影进行排序，并返回排序后的电影信息列表的方法签名。
* 实现类需要编写排序逻辑，依据电影的票房字段对获取到的电影记录进行排序（可以是按票房从高到低或者从低到高排序，具体依业务需求而定），
* 最后以`List<Movie>`集合的形式返回排序后的电影信息列表，便于按照票房高低展示电影情况，例如展示热门票房电影等业务场景。
* @return 返回一个包含`Movie`对象的`List`集合，代表排序后的电影记录信息，列表顺序依据票房排序规则确定
*/
List<Movie> sortMovieByBoxOffice();
}
Movie findMovieById(long movie_id);
Movie findMovieByName(String movie_cn_name);
Integer addMovie(Movie movie);
Integer deleteMovie(long movie_id);
Integer updateMovie(Movie movie);
Integer delCommentCount(long movie_id);
Integer changeMovieBoxOffice(float price,long movie_id);
Integer addCommentCount(long movie_id);
List<Movie> findAllMovies(int movie_state);
List<Movie> findMoviesLikeName(String name);
List<Movie> findMoviesLikeType(String type);
//上映时间 参评人数 评分
List<Movie> sortMovieByDate();
List<Movie> sortMovieByCount();
List<Movie> sortMovieByScore();
List<Movie> sortMovieByBoxOffice();
}

92
src/main/java/com/service/IOrderService.java
Unescape View File

@ -5,86 +5,14 @@ import java.util.List;
import com.entity.Order;
import com.github.pagehelper.PageInfo;
/**
* IOrderService接口，用于定义与订单（Order）相关的业务逻辑操作方法规范。
* 该接口规定了一系列诸如根据订单ID查询订单详情、添加新订单、更新订单状态（如申请退票、同意退票等操作）以及按照不同条件（用户名、订单状态等）分页查询或直接查询订单信息等功能的抽象方法，通常会由具体的实现类来实现这些方法的具体业务逻辑，实现类一般会与数据持久层交互来完成相应的数据操作，为项目中涉及订单相关业务的模块提供统一的服务调用接口，方便对订单相关业务进行统一管理和操作。
*/
public interface IOrderService {
/**
* 根据订单的唯一标识（ID）查询对应的订单信息的方法签名。
* 具体实现类需要编写逻辑（通常是调用数据持久层相关方法与数据库交互），依据传入的订单ID（一般是一个具有特定格式的字符串）从数据库中查找对应的订单记录，并将其转换为`Order`实体对象返回，方便获取特定订单的详细情况，例如订单所属用户、对应的场次、座位信息等内容。
* @param order_id 要查询的订单的唯一标识（字符串类型）
* @return 返回一个`Order`对象，代表查询到的订单信息，如果未找到对应的订单则返回`null`（具体取决于实现逻辑）
*/
Order findOrderById(String order_id);
/**
* 向数据库中插入一条新的订单记录的方法签名。
* 对应的实现类需要实现将传入的包含订单信息的`Order`对象（包含订单相关的各种属性，如用户ID、场次ID、座位选择等）插入到数据库的订单表中的逻辑，并且根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），以此判断订单信息插入是否成功。
* @param order 包含要插入的订单信息的`Order`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
Integer addOrder(Order order);
/**
* 将指定订单的状态更新为申请退票状态的方法签名。
* 实现类要编写代码逻辑，依据传入的订单唯一标识（order_id），在数据库中找到对应的订单记录，并将其订单状态字段更新为表示申请退票的值（具体值由业务逻辑中约定，例如可能是某个特定的数字代表申请退票状态），然后返回受影响的行数，用于判断订单状态更新为申请退票这一操作是否成功执行（一般成功更新返回1，不存在对应记录返回0等情况），可用于用户发起退票申请等业务场景。
* @param order_id 要更新状态为申请退票的订单的唯一标识（字符串类型）
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateOrderStateToRefund(String order_id); //申请退票
/**
* 将指定订单的状态更新为同意退票状态的方法签名。
* 实现类需要编写相应逻辑，依据传入的订单唯一标识（order_id）在数据库里定位到相应订单记录，把其订单状态字段更新为表示同意退票的值（按照业务逻辑中定义的相应状态值来更新，比如另一个特定数字表示同意退票），同样根据更新操作结果返回受影响的行数，用于判断订单状态更新为同意退票这一操作是否成功执行，可用于管理员或相关业务流程中同意用户退票申请等业务场景。
* @param order_id 要更新状态为同意退票的订单的唯一标识（字符串类型）
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
Integer updateOrderStateToRefunded(String order_id); //同意退票
/**
* 分页查询指定用户名的订单信息的方法签名。
* 实现类需要编写逻辑，先通过传入的页码（page）和每页显示记录条数（limit）设置分页参数，然后依据传入的用户名（user_name），在数据库中查找该用户的订单记录，将这些记录转换为`Order`实体对象，并进行相应的分页处理，最后以`PageInfo<Order>`对象的形式返回，`PageInfo`对象中包含了分页相关的各种信息（如总记录数、总页数、当前页数据等），方便在前端进行分页展示以及相关操作，例如用户查看自己的历史订单列表等业务场景。
* @param page 当前页码，用于指定要获取的是第几页数据，通常是从1开始计数的正整数
* @param limit 每页显示的记录条数，用于限制每页的数据量，通常是一个正整数
* @param user_name 要查询其订单的用户名，用于在数据库中筛选对应的订单记录
* @return 返回一个`PageInfo<Order>`对象，包含了分页后的指定用户名的订单信息以及分页相关的详细数据
*/
PageInfo<Order> findOrdersByUserName(Integer page, Integer limit, String user_name);
/**
* 查询数据库中所有订单信息的方法签名。
* 对应的实现类应编写逻辑，通过调用数据持久层相关方法从数据库表中获取全部的订单记录，并将每条记录转换为`Order`实体对象，最后以`List<Order>`集合的形式返回所有订单信息列表，方便进行整体的订单数据统计、管理等操作，例如管理员查看所有订单情况等业务场景。
* @return 返回一个包含所有`Order`对象的`List`集合，每个对象代表一条订单记录信息
*/
List<Order> findAllOrders();
/**
* 根据用户名查询该用户所有处于申请退票状态的订单信息的方法签名。
* 实现类需要编写逻辑，依据传入的用户名（user_name），在数据库中查找该用户名下处于申请退票状态的订单记录，将这些记录转换为`Order`实体对象，并以`List<Order>`集合的形式返回，方便查看特定用户的申请退票订单情况，例如用于处理用户退票申请相关业务流程等场景。
* @param user_name 要查询其申请退票订单的用户名，用于在数据库中筛选对应的订单记录
* @return 返回一个包含符合条件的`Order`对象的`List`集合，每个对象代表一条申请退票的订单记录信息，可能为空集合（如果该用户没有申请退票的订单）
*/
List<Order> findRefundOrderByUserName(String user_name);
/**
* 分页查询符合指定状态的订单信息的方法签名。
* 实现类需要编写逻辑，先通过传入的页码（page）和每页显示记录条数（limit）设置分页参数，然后依据传入的订单状态值（order_state，通常是一个整数表示不同状态，例如1表示已支付，0表示退票中等等，具体依业务定义而定），在数据库中筛选出处于该状态的订单记录，将这些记录转换为`Order`实体对象，并进行相应的分页处理，最后以`PageInfo<Order>`对象的形式返回，方便按状态查看订单情况并进行分页展示，例如统计不同状态订单的数量等业务操作。
* @param page 当前页码，用于指定要获取的是第几页数据，通常是从1开始计数的正整数
* @param limit 每页显示的记录条数，用于限制每页的数据量，通常是一个正整数
* @param order_state 表示订单状态的整数，用于筛选符合该状态的订单记录
* @return 返回一个`PageInfo<Order>`对象，包含了分页后的符合指定状态的订单信息以及分页相关的详细数据
*/
PageInfo<Order> findOrdersByState(Integer page, Integer limit, int order_state);
/**
* 分页查询所有订单信息的方法签名，支持根据关键词进行筛选（如果关键词不为空，则按一定规则筛选订单，比如按用户名模糊查询等，具体规则可由实现类确定）。
* 实现类需要编写逻辑，先通过传入的页码（page）和每页显示记录条数（limit）设置分页参数，然后根据关键词（keyword）情况决定查询逻辑：如果关键词不为空，则按照相应规则筛选订单记录；若关键词为空，则查询全部订单记录。之后将筛选出的记录转换为`Order`实体对象，并进行分页处理，最后以`PageInfo<Order>`对象的形式返回，方便进行订单信息的分页展示以及通过关键词快速查找相关订单等业务场景，例如用户通过输入关键词搜索订单等情况。
* @param page 当前页码，用于指定要获取的是第几页数据，通常是从1开始计数的正整数
* @param limit 每页显示的记录条数，用于限制每页的数据量，通常是一个正整数
* @param keyword 关键词，用于筛选订单记录，如果为`null`或者空字符串则查询全部订单
* @return 返回一个`PageInfo<Order>`对象，包含了分页后的订单信息以及分页相关的详细数据
*/
PageInfo<Order> findAllOrdersBySplitPage(Integer page, Integer limit, String keyword);
}
Order findOrderById(String order_id);
Integer addOrder(Order order);
Integer updateOrderStateToRefund(String order_id); //申请退票
Integer updateOrderStateToRefunded(String order_id); //同意退票
PageInfo<Order> findOrdersByUserName(Integer page,Integer limit,String user_name);
List<Order> findAllOrders();
List<Order> findRefundOrderByUserName(String user_name);
PageInfo<Order> findOrdersByState(Integer page,Integer limit,int order_state);
PageInfo<Order> findAllOrdersBySplitPage(Integer page,Integer limit,String keyword);
}

123
src/main/java/com/service/IScheduleService.java
Unescape View File

@ -1,116 +1,21 @@
package com.service;
import java.util.List;
import com.entity.Schedule;
import com.github.pagehelper.PageInfo;
/**
* IScheduleService 是排片服务层的接口，定义了与排片相关的业务逻辑操作。
*/
public interface IScheduleService {
/**
* 根据排片 ID 查询单个排片信息。
*
* @param schedule_id 要查询的排片 ID
* @return 返回包含排片信息的 Schedule 实体对象；如果未找到，则返回 null
*/
Schedule findScheduleById(long schedule_id);
/**
* 添加新的排片信息到数据库。
*
* @param schedule 包含要添加的排片信息的 Schedule 实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer addSchedule(Schedule schedule);
/**
* 更新指定 ID 的排片信息。
*
* @param schedule 包含更新信息的 Schedule 实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer updateSchedule(Schedule schedule);
/**
* 从数据库中删除指定 ID 的排片信息（实际是将排片下架，并非物理删除）。
*
* @param schedule_id 要下架的排片 ID
* @return 如果删除成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer deleteSchedule(long schedule_id);
/**
* 增加指定排片的剩余座位数。
*
* @param schedule_id 要增加剩余座位数的排片 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer addScheduleRemain(long schedule_id);
/**
* 减少指定排片的剩余座位数。
*
* @param schedule_id 要减少剩余座位数的排片 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
Integer delScheduleRemain(long schedule_id);
/**
* 分页查询符合条件的排片信息（根据电影名称），并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param movie_name 电影名称
* @return 返回包含分页信息和排片列表的 PageInfo 对象
*/
PageInfo<Schedule> findScheduleByMovieName(Integer page, Integer limit, String movie_name);
/**
* 分页查询已下架的排片信息（根据电影名称），并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param movie_name 电影名称
* @return 返回包含分页信息和排片列表的 PageInfo 对象
*/
PageInfo<Schedule> findOffScheduleByMovieName(Integer page, Integer limit, String movie_name);
/**
* 分页查询所有排片信息，并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @return 返回包含分页信息和排片列表的 PageInfo 对象
*/
PageInfo<Schedule> findAllSchedule(Integer page, Integer limit);
/**
* 分页查询符合条件的排片信息（根据排片状态），并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param schedule_state 排片状态码
* @return 返回包含分页信息和排片列表的 PageInfo 对象
*/
PageInfo<Schedule> findAllScheduleByState(Integer page, Integer limit, int schedule_state);
/**
* 根据影院 ID 和电影 ID 查询符合条件的排片信息。
*
* @param cinema_id 影院 ID
* @param movie_id 电影 ID
* @return 返回符合条件的 Schedule 实体对象列表
*/
List<Schedule> findScheduleByCinemaAndMovie(long cinema_id, long movie_id);
/**
* 为 selectSeat 页面提供接口，根据影院 ID 和电影 ID 查询符合条件的排片信息，并加载关联的影厅、影院和电影。
*
* @param cinema_id 影院 ID
* @param movie_id 电影 ID
* @return 返回符合条件的 Schedule 实体对象列表
*/
List<Schedule> findScheduleByCineamIdAndMovieId(long cinema_id, long movie_id);
}
Schedule findScheduleById(long schedule_id);
Integer addSchedule(Schedule schedule);
Integer updateSchedule(Schedule schedule);
Integer deleteSchedule(long schedule_id);
Integer addScheduleRemain(long schedule_id);
Integer delScheduleRemain(long schedule_id);
PageInfo<Schedule> findScheduleByMovieName(Integer page,Integer limit,String movie_name);
PageInfo<Schedule> findOffScheduleByMovieName(Integer page,Integer limit,String movie_name);
PageInfo<Schedule> findAllSchedule(Integer page,Integer limit);
PageInfo<Schedule> findAllScheduleByState(Integer page,Integer limit,int schedule_state);
List<Schedule> findScheduleByCinemaAndMovie(long cinema_id,long movie_id);
List<Schedule> findScheduleByCineamIdAndMovieId(long cinema_id,long movie_id);
}

90
src/main/java/com/service/IUserService.java
Unescape View File

@ -1,87 +1,19 @@
package com.service;
import java.util.List;
import com.entity.User;
import com.github.pagehelper.PageInfo;
/**
* IUserService接口，用于定义一系列针对用户（User）相关业务逻辑操作的方法规范。
* 该接口规定了诸如用户登录验证、更新用户信息、根据不同条件（如用户ID、用户名等）查询用户信息、添加新用户、删除用户以及分页查询用户信息等功能的抽象方法，通常会由具体的实现类来实现这些方法的具体业务逻辑，实现类一般会与数据持久层交互完成相应的数据操作，为项目中涉及用户相关业务的各个模块提供统一的服务调用接口，方便对用户相关业务进行统一管理和操作。
*/
public interface IUserService {
/**
* 用户登录验证的方法签名，用于验证输入的用户名和密码是否匹配，进而判断用户能否成功登录。
* 具体实现类需编写逻辑（通常调用数据持久层相关方法与数据库交互），依据传入的用户名（user_name）在数据库中查找对应的用户记录，然后比对这些用户记录中的密码与传入的密码（user_pwd）是否一致，若找到匹配的记录，则返回对应的用户对象，表示登录成功；若未找到匹配记录，则返回`null`，代表登录失败。
* @param user_name 要登录的用户名，用于在数据库中筛选对应的用户记录，通常是一个具有特定格式的字符串。
* @param user_pwd 要登录的用户输入的密码，用于和数据库中存储的用户密码进行比对验证，同样是字符串类型。
* @return 返回一个`User`对象，表示登录验证成功的用户信息，如果验证失败则返回`null`。
*/
User login(String user_name, String user_pwd);
/**
* 根据传入的用户对象信息更新数据库中对应的用户记录的方法签名。
* 实现类要编写代码逻辑，依据传入的包含更新后用户信息的`User`对象（其属性值代表了要更新的具体内容，如用户昵称、联系方式等发生变化的信息），调用数据持久层相关方法来更新数据库里对应用户记录的相应字段，然后返回受影响的行数，用于判断更新操作是否成功执行（通常更新成功返回1，失败返回0等，具体依数据库执行情况而定）。
* @param user 包含更新后用户信息的`User`对象，其各属性值将用于更新数据库中对应的用户记录字段。
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功。
*/
Integer updateUserInfo(User user);
/**
* 根据用户的唯一标识（ID）查询对应的用户信息的方法签名。
* 具体实现类需要编写逻辑（通过调用数据持久层相关方法与数据库交互），依据传入的用户ID（一般是一个具有特定格式的数字）从数据库中查找对应的用户记录，并将其转换为`User`实体对象返回，方便获取特定用户的详细情况，例如用户的基本资料、权限信息等内容。
* @param user_id 要查询的用户的唯一标识（长整型数字）。
* @return 返回一个`User`对象，代表查询到的用户信息，如果未找到对应的用户则返回`null`（具体取决于实现逻辑）。
*/
User findUserById(long user_id);
/**
* 根据用户名查询对应的用户信息列表的方法签名。
* 实现类需编写相应逻辑，按照传入的用户名（name），在数据库中查找匹配的用户记录，并将这些记录转换为`User`实体对象，最后以`List<User>`集合的形式返回这些用户信息列表，方便通过用户名来查找特定用户，例如在用户搜索功能中使用，可用于查找具有相同或相似用户名的用户等场景。
* @param name 要查询的用户名，用于在数据库中筛选对应的用户记录，通常是一个字符串类型。
* @return 返回一个包含符合条件的`User`对象的`List`集合，每个对象代表一条匹配用户名的用户记录信息，可能为空集合（如果没有找到对应的用户）。
*/
List<User> findUserByName(String name);
/**
* 根据用户名进行模糊查询，获取符合模糊条件的用户信息列表的方法签名。
* 实现类需要编写逻辑，依据传入的用户名（name，可以是部分用户名等模糊条件），在数据库中查找名称符合模糊匹配条件的用户记录，将这些记录转换为`User`实体对象，最后以`List<User>`集合的形式返回这些用户信息列表，方便用户根据部分名称等模糊信息查找感兴趣的用户，例如在更宽泛的用户搜索场景中使用。
* @param name 要进行模糊查询的用户名，用于筛选符合条件的用户记录，通常是一个字符串类型。
* @return 返回一个包含符合模糊查询条件的`User`对象的`List`集合，可能为空集合（如果没有找到符合条件的用户）。
*/
List<User> findUserLikeName(String name);
/**
* 向数据库中插入一条新的用户记录的方法签名。
* 对应的实现类需要实现将传入的包含新用户信息的`User`对象（包含用户的各种属性，如用户名、密码、邮箱等）插入到数据库的用户表中的逻辑，并且根据插入操作的结果返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），以此判断用户信息插入是否成功。
* @param user 包含要插入的新用户信息的`User`对象，其各属性值将被插入到数据库用户表的对应字段中。
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功。
*/
Integer addUser(User user);
/**
* 根据用户的唯一标识（ID）从数据库中删除对应的用户记录的方法签名。
* 具体实现类需编写逻辑，调用相应的数据持久层方法将指定ID的用户记录从数据库表中移除，然后返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况），用于确认用户记录删除操作的结果。
* @param user_id 要删除的用户的唯一标识（长整型数字）。
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功。
*/
Integer deleteUser(long user_id);
/**
* 查询数据库中所有用户信息的方法签名。
* 对应的实现类应编写逻辑，通过调用数据持久层相关方法从数据库表中获取全部的用户记录，并将每条记录转换为`User`实体对象，最后以`List<User>`集合的形式返回所有用户信息列表，方便进行整体的用户数据统计、管理等操作，例如展示所有用户列表供管理员查看等业务场景。
* @return 返回一个包含所有`User`对象的`List`集合，每个对象代表一条用户记录信息。
*/
List<User> findAllUserInfos();
/**
* 分页查询所有用户信息的方法签名，支持根据关键词进行筛选（如果关键词不为空，则按一定规则筛选用户，比如按用户名模糊查询等，具体规则可由实现类确定）。
* 实现类需要编写逻辑，先通过传入的页码（page）和每页显示记录条数（limit）设置分页参数，然后根据关键词（keyword）情况决定查询逻辑：如果关键词不为空，则按照相应规则筛选用户记录；若关键词为空，则查询全部用户记录。之后将筛选出的记录转换为`User`实体对象，并进行分页处理，最后以`PageInfo<User>`对象的形式返回，方便进行用户信息的分页展示以及通过关键词快速查找相关用户等业务场景，例如用户通过输入关键词搜索用户等情况。
* @param page 当前页码，用于指定要获取的是第几页数据，通常是从1开始计数的正整数。
* @param limit 每页显示的记录条数，用于限制每页的数据量，通常是一个正整数。
* @param keyword 关键词，用于筛选用户记录，如果为`null`或者空字符串则查询全部用户。
* @return 返回一个`PageInfo<User>`对象，包含了分页后的用户信息以及分页相关的详细数据。
*/
PageInfo<User> findAllUserBySplitPage(Integer page, Integer limit, String keyword);
}
User login(String user_name,String user_pwd);
Integer updateUserInfo(User user);
User findUserById(long user_id);
List<User> findUserByName(String name);
List<User> findUserLikeName(String name);
Integer addUser(User user);
Integer deleteUser(long user_id);
List<User> findAllUserInfos();
PageInfo<User> findAllUserBySplitPage(Integer page,Integer limit,String keyword);
}

175
src/main/java/com/service/imp/CinemaServiceImp.java
Unescape View File

@ -16,118 +16,75 @@ import com.mapper.ScheduleMapper;
import com.service.ICinemaService;
@Service
public class CinemaServiceImp implements ICinemaService {
public class CinemaServiceImp implements ICinemaService{
@Autowired
private CinemaMapper cinemaMapper;
@Autowired
private HallMapper hallMapper;
@Autowired
private ScheduleMapper scheduleMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Cinema findCinemaById(long cinema_id) {
Cinema cinema = this.cinemaMapper.findCinemaById(cinema_id);
List<Hall> list = this.hallMapper.findHallByCinemaId(cinema_id);
cinema.setHallList(list);
return cinema;
}
@Autowired
private CinemaMapper cinemaMapper; // 依赖注入 CinemaMapper 用于执行与影院相关的数据库操作
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Cinema> findCinemasByMovieId(long movie_id) {
List<Cinema> cinemaList = this.cinemaMapper.findCinemasByMovieId(movie_id);
for(Cinema cinema : cinemaList) {
List<Hall> hallList = this.hallMapper.findHallByCinemaId(cinema.getCinema_id());
for(Hall hall : hallList) {
hall.setScheduleList(this.scheduleMapper.findScheduleByCinemaAndMovieAndHall(hall.getHall_id(), hall.getCinema_id(), movie_id));
}
cinema.setHallList(hallList);
}
return cinemaList;
}
@Autowired
private HallMapper hallMapper; // 依赖注入 HallMapper 用于执行与影厅相关的数据库操作
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addCinema(Cinema cinema) {
return this.cinemaMapper.addCinema(cinema);
}
@Autowired
private ScheduleMapper scheduleMapper; // 依赖注入 ScheduleMapper 用于执行与日程表相关的数据库操作
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateCinema(Cinema cinema) {
return this.cinemaMapper.updateCinema(cinema);
}
/**
* 根据影院 ID 查询单个影院信息，并加载关联的影厅列表。
*
* @param cinema_id 要查询的影院 ID
* @return 返回包含影院及其影厅列表的 Cinema 实体对象；如果未找到，则返回 null
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public Cinema findCinemaById(long cinema_id) {
Cinema cinema = this.cinemaMapper.findCinemaById(cinema_id);
List<Hall> list = this.hallMapper.findHallByCinemaId(cinema_id);
cinema.setHallList(list); // 设置影院的影厅列表
return cinema;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteCinema(long cinema_id) {
return this.cinemaMapper.deleteCinema(cinema_id);
}
/**
* 根据电影 ID 查询所有放映该电影的影院信息，并加载关联的影厅和日程表列表。
*
* @param movie_id 要查询的电影 ID
* @return 返回包含影院、影厅及日程表列表的 Cinema 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Cinema> findCinemasByMovieId(long movie_id) {
List<Cinema> cinemaList = this.cinemaMapper.findCinemasByMovieId(movie_id);
for (Cinema cinema : cinemaList) {
List<Hall> hallList = this.hallMapper.findHallByCinemaId(cinema.getCinema_id());
for (Hall hall : hallList) {
hall.setScheduleList(this.scheduleMapper.findScheduleByCinemaAndMovieAndHall(hall.getHall_id(), hall.getCinema_id(), movie_id));
}
cinema.setHallList(hallList); // 设置影院的影厅列表，包括各影厅的日程表
}
return cinemaList;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Cinema> findAllCinemas() {
List<Cinema> list = this.cinemaMapper.findAllCinemas();
for(Cinema cinema : list) {
List<Hall> hallList = this.hallMapper.findHallByCinemaId(cinema.getCinema_id());
cinema.setHallList(hallList);
}
return list;
}
/**
* 添加新的影院信息到数据库。
*
* @param cinema 包含要添加的影院信息的 Cinema 实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer addCinema(Cinema cinema) {
return this.cinemaMapper.addCinema(cinema);
}
/**
* 更新指定 ID 的影院信息。
*
* @param cinema 包含更新信息的 Cinema 实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer updateCinema(Cinema cinema) {
return this.cinemaMapper.updateCinema(cinema);
}
/**
* 从数据库中删除指定 ID 的影院信息。
*
* @param cinema_id 要删除的影院 ID
* @return 如果删除成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer deleteCinema(long cinema_id) {
return this.cinemaMapper.deleteCinema(cinema_id);
}
/**
* 查询所有影院信息，并加载关联的影厅列表。
*
* @return 返回包含所有影院及其影厅列表的 Cinema 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Cinema> findAllCinemas() {
List<Cinema> list = this.cinemaMapper.findAllCinemas();
for (Cinema cinema : list) {
List<Hall> hallList = this.hallMapper.findHallByCinemaId(cinema.getCinema_id());
cinema.setHallList(hallList); // 设置影院的影厅列表
}
return list;
}
/**
* 根据影院名称模糊查询影院信息，并加载关联的影厅列表。
*
* @param cinema_name 包含要查询的关键字的影院名称
* @return 返回匹配影院名称的 Cinema 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Cinema> findCinemasLikeName(String cinema_name) {
List<Cinema> list = this.cinemaMapper.findCinemasLikeName(cinema_name);
for (Cinema cinema : list) {
List<Hall> hallList = this.hallMapper.findHallByCinemaId(cinema.getCinema_id());
cinema.setHallList(hallList); // 设置影院的影厅列表
}
return list;
}
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Cinema> findCinemasLikeName(String cinema_name) {
List<Cinema> list = this.cinemaMapper.findCinemasLikeName(cinema_name);
for(Cinema cinema : list) {
List<Hall> hallList = this.hallMapper.findHallByCinemaId(cinema.getCinema_id());
cinema.setHallList(hallList);
}
return list;
}
}

194
src/main/java/com/service/imp/CommentServiceImp.java
Unescape View File

@ -14,139 +14,77 @@ import com.github.pagehelper.PageInfo;
import com.mapper.CommentMapper;
import com.service.ICommentService;
/**
* CommentServiceImp类，它实现了ICommentService接口，用于处理评论（Comment）相关的业务逻辑。
* 该类通过依赖注入获取CommentMapper对象，进而调用对应的数据库操作方法，并且利用Spring的事务管理机制来确保数据库操作的一致性以及控制事务的传播行为等。
* 通过`@Service`注解将该类标记为Spring的服务层组件，便于Spring框架进行管理以及在其他组件中进行依赖注入使用。
*/
@Service
public class CommentServiceImp implements ICommentService {
public class CommentServiceImp implements ICommentService{
/**
* 通过Spring的依赖注入机制自动注入CommentMapper对象，用于调用数据持久层的相关方法，实现与数据库中评论表的交互，例如查询、插入、更新和删除评论记录等操作。
*/
@Autowired
private CommentMapper commentMapper;
@Autowired
private CommentMapper commentMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Comment findCommentById(long comment_id) {
return this.commentMapper.findCommentById(comment_id);
}
/**
* 根据评论的唯一标识（ID）查询评论信息的方法。
* 该方法被标记为事务性方法，事务传播行为设置为`Propagation.REQUIRED`，意味着如果当前存在事务，则加入该事务；如果不存在，则创建一个新事务。同时设置为只读事务（`readOnly=true`），因为该操作只是查询数据，不需要进行数据修改，提高性能并优化数据库资源利用。
* 方法内部直接调用CommentMapper的`findCommentById`方法从数据库中获取对应的评论记录，并返回查询到的评论对象。
* @param comment_id 要查询的评论的唯一标识（ID）
* @return 返回一个`Comment`对象，代表查询到的评论信息，如果未找到则返回`null`（具体取决于底层Mapper的实现逻辑）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Comment findCommentById(long comment_id) {
return this.commentMapper.findCommentById(comment_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addComemnt(Comment comment) {
return this.commentMapper.addComemnt(comment);
}
/**
* 向数据库中添加一条新评论记录的方法。
* 此方法同样是事务性方法，事务传播行为为`Propagation.REQUIRED`，且设置了`rollbackFor=Exception.class`，表示如果方法执行过程中抛出任何异常，都会回滚当前事务，保证数据的一致性。
* 内部通过调用CommentMapper的`addComemnt`方法，将传入的评论对象（包含评论的相关内容等属性）插入到数据库的评论表中，并返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），用于判断插入操作是否成功。
* @param comment 包含要插入的评论信息的`Comment`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer addComemnt(Comment comment) {
return this.commentMapper.addComemnt(comment);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateComment(Comment comment) {
return this.commentMapper.updateComment(comment);
}
/**
* 根据传入的评论对象信息更新数据库中对应的评论记录的方法。
* 也是事务性方法，事务传播行为和异常回滚设置与添加评论的方法类似，保证更新操作在出现异常时能正确回滚事务。
* 通过调用CommentMapper的`updateComment`方法，依据传入的评论对象的属性值来更新数据库里对应评论记录的相应字段，然后返回受影响的行数，用于判断更新操作是否成功执行。
* @param comment 包含更新后评论信息的`Comment`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer updateComment(Comment comment) {
return this.commentMapper.updateComment(comment);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteComment(long comment_id) {
return this.commentMapper.deleteComment(comment_id);
}
/**
* 根据评论的唯一标识（ID）从数据库中删除对应的评论记录的方法。
* 事务配置与上述更新、插入方法类似，确保删除操作的事务一致性。
* 调用CommentMapper的`deleteComment`方法，依据传入的评论ID从数据库评论表中移除对应的记录，并返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况）。
* @param comment_id 要删除的评论的唯一标识
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer deleteComment(long comment_id) {
return this.commentMapper.deleteComment(comment_id);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Comment> findAllComments() {
return this.commentMapper.findAllComments();
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Comment> findAllCommentsBySplitPage(Integer page, Integer limit, String keyword) {
PageHelper.startPage(page, limit);
List<Comment> list = new ArrayList<Comment>();
if(keyword != null && !keyword.trim().equals("")) {
System.out.println("keyword:"+keyword);
list = this.commentMapper.findCommentsByUserName(keyword);
}else {
//System.out.println("keyword:"+keyword);
list = this.commentMapper.findAllComments();
}
PageInfo<Comment> info = new PageInfo<Comment>(list);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Comment> findCommentsByUserName(Integer page, Integer limit,String user_name) {
PageHelper.startPage(page,limit);
List<Comment> list = new ArrayList<Comment>();
list = this.commentMapper.findCommentsByUserName(user_name);
PageInfo<Comment> info = new PageInfo<Comment>(list);
return info;
}
/**
* 查询数据库中所有评论信息的方法。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 内部直接调用CommentMapper的`findAllComments`方法从数据库中获取所有评论记录，并以列表形式返回所有的评论对象集合，方便后续在业务逻辑中对全部评论进行处理，例如展示所有评论列表等情况。
* @return 返回一个包含所有`Comment`对象的`List`集合，每个对象代表一条评论记录信息
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Comment> findAllComments() {
return this.commentMapper.findAllComments();
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Comment> findCommentsByMovieId(long movie_id) {
return this.commentMapper.findCommentsByMoiveId(movie_id);
}
/**
* 分页查询所有评论信息的方法，支持根据关键词筛选评论（如果关键词不为空，则按用户名模糊查询评论）。
* 事务传播行为为`Propagation.REQUIRED`且为只读事务，用于确保查询操作在事务环境下正确执行以及优化性能。
* 首先通过`PageHelper.startPage(page, limit)`设置分页参数，然后根据关键词情况决定查询逻辑：如果关键词不为空且去除空格后不为空字符串，就调用CommentMapper的`findCommentsByUserName`方法按用户名进行模糊查询获取评论列表；否则直接调用`findAllComments`方法获取所有评论列表。
* 最后将查询到的评论列表封装到`PageInfo`对象中，`PageInfo`对象包含了分页相关的各种信息（如总记录数、总页数、当前页数据等），便于在前端展示分页效果以及进行相关分页操作的处理，然后返回这个`PageInfo`对象。
* @param page 当前页码，用于指定要获取的是第几页数据
* @param limit 每页显示的记录条数，用于限制每页的数据量
* @param keyword 关键词，用于按用户名模糊查询评论，如果为`null`或者空字符串则查询全部评论
* @return 返回一个`PageInfo<Comment>`对象，包含了分页后的评论信息以及分页相关的详细数据
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Comment> findAllCommentsBySplitPage(Integer page, Integer limit, String keyword) {
PageHelper.startPage(page, limit);
List<Comment> list = new ArrayList<Comment>();
if (keyword!= null &&!keyword.trim().equals("")) {
System.out.println("keyword:" + keyword);
list = this.commentMapper.findCommentsByUserName(keyword);
} else {
//System.out.println("keyword:" + keyword);
list = this.commentMapper.findAllComments();
}
PageInfo<Comment> info = new PageInfo<Comment>(list);
return info;
}
/**
* 分页查询指定用户名的评论信息的方法。
* 同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 先通过`PageHelper.startPage(page,limit)`设置分页参数，然后调用CommentMapper的`findCommentsByUserName`方法按传入的用户名获取对应的评论列表，最后将该列表封装到`PageInfo`对象中返回，便于前端进行分页展示和相关处理。
* @param page 当前页码，用于指定要获取的是第几页数据
* @param limit 每页显示的记录条数，用于限制每页的数据量
* @param user_name 要查询其评论的用户名，用于筛选对应的评论记录
* @return 返回一个`PageInfo<Comment>`对象，包含了分页后的指定用户名的评论信息以及分页相关的详细数据
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Comment> findCommentsByUserName(Integer page, Integer limit, String user_name) {
PageHelper.startPage(page, limit);
List<Comment> list = new ArrayList<Comment>();
list = this.commentMapper.findCommentsByUserName(user_name);
PageInfo<Comment> info = new PageInfo<Comment>(list);
return info;
}
/**
* 根据电影的唯一标识（ID）查询该电影对应的所有评论信息的方法。
* 方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 内部直接调用CommentMapper的`findCommentsByMoiveId`方法，从数据库中获取指定电影的所有评论记录，并以列表形式返回这些评论对象集合，方便在业务逻辑中展示某部电影的所有评论情况，例如在电影详情页面展示评论等。
* @param movie_id 要查询其评论的电影的唯一标识（ID）
* @return 返回一个包含符合条件的`Comment`对象的`List`集合，每个对象代表一条该电影的评论记录信息
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Comment> findCommentsByMovieId(long movie_id) {
return this.commentMapper.findCommentsByMoiveId(movie_id);
}
}
}

169
src/main/java/com/service/imp/HallServiceImp.java
Unescape View File

@ -12,125 +12,64 @@ import com.mapper.CinemaMapper;
import com.mapper.HallMapper;
import com.service.IHallService;
/**
* HallServiceImp类，它实现了IHallService接口，主要用于处理放映厅（Hall）相关的业务逻辑。
* 该类通过Spring的依赖注入机制获取了HallMapper和CinemaMapper对象，分别用于执行与放映厅数据以及电影院数据相关的持久化操作，并且运用Spring的事务管理特性来保障数据操作的一致性和完整性等。
* 通过`@Service`注解将该类标记为Spring的服务层组件，便于Spring框架进行管理以及在其他组件中被依赖注入使用。
*/
@Service
public class HallServiceImp implements IHallService {
public class HallServiceImp implements IHallService{
@Autowired
private HallMapper hallMapper;
@Autowired
private CinemaMapper cinemaMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Hall findHallById(long hall_id) {
Hall hall = this.hallMapper.findHallById(hall_id);
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
return hall;
}
/**
* 通过Spring的依赖注入自动获取HallMapper对象，用于调用与放映厅数据持久化相关的方法，例如查询、插入、更新和删除放映厅记录等操作，这些操作最终会与数据库中的放映厅表进行交互。
*/
@Autowired
private HallMapper hallMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Hall findHallByCinemaAndHallName(String cinema_name, String hall_name) {
return this.hallMapper.findHallByCinemaAndHallName(cinema_name, hall_name);
}
/**
* 通过Spring的依赖注入自动获取CinemaMapper对象，用于调用与电影院数据持久化相关的方法，主要用于在处理放映厅业务时，可能需要关联查询电影院的相关信息，比如获取放映厅所属的电影院详情等操作，与数据库中的电影院表进行交互。
*/
@Autowired
private CinemaMapper cinemaMapper;
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addHall(Hall hall) {
return this.hallMapper.addHall(hall);
}
/**
* 根据放映厅的唯一标识（ID）查询放映厅信息的方法。
* 该方法被标记为事务性方法，事务传播行为设置为`Propagation.REQUIRED`，表示如果当前存在事务，则加入该事务；如果不存在，则创建一个新事务。同时设置为只读事务（`readOnly=true`），因为此操作主要是查询数据，不需要进行数据修改，这样可以提高性能并优化数据库资源利用。
* 首先通过HallMapper的`findHallById`方法从数据库中获取指定ID的放映厅基本信息，然后利用获取到的放映厅对象中的电影院ID，再通过CinemaMapper的`findCinemaById`方法获取该放映厅所属的电影院信息，并设置到放映厅对象中，最后返回包含完整电影院关联信息的放映厅对象。
* @param hall_id 要查询的放映厅的唯一标识（ID）
* @return 返回一个`Hall`对象，代表查询到的放映厅信息，其中包含了所属电影院的详细信息，如果未找到对应放映厅则返回`null`（具体取决于底层Mapper的实现逻辑）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Hall findHallById(long hall_id) {
Hall hall = this.hallMapper.findHallById(hall_id);
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
return hall;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateHall(Hall hall) {
return this.hallMapper.updateHall(hall);
}
/**
* 根据电影院名称和放映厅名称来查询放映厅信息的方法。
* 该方法同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 直接调用HallMapper的`findHallByCinemaAndHallName`方法，依据传入的电影院名称和放映厅名称从数据库中查找对应的放映厅记录，并返回查询到的放映厅对象，方便在已知电影院和放映厅具体名称的情况下获取相应的放映厅信息。
* @param cinema_name 要查询的放映厅所属电影院的名称
* @param hall_name 要查询的放映厅的名称
* @return 返回一个`Hall`对象，代表查询到的符合条件的放映厅信息，如果未找到则返回`null`（具体取决于底层Mapper的实现逻辑）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Hall findHallByCinemaAndHallName(String cinema_name, String hall_name) {
return this.hallMapper.findHallByCinemaAndHallName(cinema_name, hall_name);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteHall(long hall_id) {
return this.hallMapper.deleteHall(hall_id);
}
/**
* 向数据库中插入一条新的放映厅记录的方法。
* 此方法是事务性方法，事务传播行为为`Propagation.REQUIRED`，且设置了`rollbackFor=Exception.class`，意味着如果方法执行过程中抛出任何异常，都会回滚当前事务，以此保证数据的一致性，确保插入操作要么全部成功，要么全部失败。
* 内部通过调用HallMapper的`addHall`方法，将传入的包含放映厅信息的`Hall`对象插入到数据库的放映厅表中，并返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），用于判断插入操作是否成功。
* @param hall 包含要插入的放映厅信息的`Hall`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer addHall(Hall hall) {
return this.hallMapper.addHall(hall);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Hall> findHallByCinemaId(long cinema_id) {
List<Hall> list = this.hallMapper.findHallByCinemaId(cinema_id);
for(Hall hall : list) {
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
}
return list;
}
/**
* 根据传入的`Hall`对象信息更新数据库中对应的放映厅记录的方法。
* 同样是事务性方法，事务传播行为和异常回滚设置与插入方法类似，保证在更新过程中出现异常时能正确回滚事务，维持数据的完整性。
* 通过调用HallMapper的`updateHall`方法，依据传入的放映厅对象的属性值来更新数据库里对应放映厅记录的相应字段，然后返回受影响的行数，用于判断更新操作是否成功执行。
* @param hall 包含更新后放映厅信息的`Hall`对象
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer updateHall(Hall hall) {
return this.hallMapper.updateHall(hall);
}
/**
* 根据放映厅的唯一标识（ID）从数据库中删除对应的放映厅记录的方法。
* 也是事务性方法，事务传播行为和异常回滚设置与上述更新、插入方法一致，确保删除操作的事务一致性，防止出现数据不一致的情况。
* 调用HallMapper的`deleteHall`方法，依据传入的放映厅ID从数据库放映厅表中移除对应的记录，并返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况）。
* @param hall_id 要删除的放映厅的唯一标识
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer deleteHall(long hall_id) {
return this.hallMapper.deleteHall(hall_id);
}
/**
* 根据电影院的唯一标识（ID）查询该电影院下所有放映厅信息的方法。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 首先通过HallMapper的`findHallByCinemaId`方法获取指定电影院下的所有放映厅基本信息列表，然后遍历该列表，针对每个放映厅对象，利用其电影院ID通过CinemaMapper的`findCinemaById`方法获取所属电影院信息，并设置到对应的放映厅对象中，最后返回包含完整电影院关联信息的放映厅列表，方便获取某一电影院包含的所有放映厅及其所属电影院的详细情况。
* @param cinema_id 要查询其下放映厅的电影院的唯一标识（ID）
* @return 返回一个包含所有符合条件的`Hall`对象的`List`集合，每个对象代表一条放映厅记录信息，且其中包含了所属电影院的详细信息，可能为空集合（如果该电影院没有放映厅）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Hall> findHallByCinemaId(long cinema_id) {
List<Hall> list = this.hallMapper.findHallByCinemaId(cinema_id);
for (Hall hall : list) {
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
}
return list;
}
/**
* 查询数据库中所有放映厅信息的方法。
* 同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 先通过HallMapper的`findAllHalls`方法获取所有放映厅的基本信息列表，接着遍历该列表，为每个放映厅对象通过其电影院ID利用CinemaMapper的`findCinemaById`方法获取所属电影院信息，并设置到对应的放映厅对象中，最后返回包含完整电影院关联信息的所有放映厅列表，便于获取整体的放映厅及其所属电影院的详细情况。
* @param list 返回一个包含所有`Hall`对象的`List`集合，每个对象代表一条放映厅记录信息，且其中包含了所属电影院的详细信息
* @return 返回包含完整电影院关联信息的所有放映厅列表，可用于展示所有放映厅及其所属电影院信息等业务场景
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Hall> findAllHalls() {
List<Hall> list = this.hallMapper.findAllHalls();
for (Hall hall : list) {
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
}
return list;
}
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Hall> findAllHalls() {
List<Hall> list = this.hallMapper.findAllHalls();
for(Hall hall : list) {
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
}
return list;
}
}

302
src/main/java/com/service/imp/MovieServiceImp.java
Unescape View File

@ -1,4 +1,4 @@
package com.service.imp;
package com.service.imp;
import java.util.List;
@ -15,197 +15,109 @@ import com.mapper.UserMapper;
import com.service.IMovieService;
@Service
public class MovieServiceImp implements IMovieService {
@Autowired
private MovieMapper movieMapper; // 依赖注入 MovieMapper 用于执行与电影相关的数据库操作
@Autowired
private CommentMapper commentMapper; // 依赖注入 CommentMapper 用于执行与评论相关的数据库操作
@Autowired
private UserMapper userMapper; // 依赖注入 UserMapper 用于执行与用户相关的数据库操作
/**
* 根据电影 ID 查询单个电影信息，并加载关联的评论列表及评论对应的用户信息。
*
* @param movie_id 要查询的电影 ID
* @return 返回包含电影及其评论和评论用户的 Movie 实体对象；如果未找到，则返回 null
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public Movie findMovieById(long movie_id) {
Movie movie = this.movieMapper.findMovieById(movie_id);
List<Comment> list = this.commentMapper.findCommentsByMoiveId(movie_id);
for (Comment comment : list) {
comment.setComment_user(this.userMapper.findUserById(comment.getUser_id())); // 设置评论的用户信息
}
movie.setCommentList(list); // 设置电影的评论列表
return movie;
}
/**
* 更新指定电影的票房信息。
*
* @param price 票房金额
* @param movie_id 要更新票房的电影 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer changeMovieBoxOffice(float price, long movie_id) {
return this.movieMapper.changeMovieBoxOffice(price, movie_id);
}
/**
* 根据电影中文名称精确查询电影信息。
*
* @param movie_cn_name 要查询的电影中文名称
* @return 返回匹配的 Movie 实体对象；如果未找到，则返回 null
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public Movie findMovieByName(String movie_cn_name) {
return this.movieMapper.findMovieByName(movie_cn_name);
}
/**
* 增加指定电影的评论计数。
*
* @param movie_id 要增加评论计数的电影 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer addCommentCount(long movie_id) {
return this.movieMapper.addMovieCommentCount(movie_id);
}
/**
* 减少指定电影的评论计数。
*
* @param movie_id 要减少评论计数的电影 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer delCommentCount(long movie_id) {
return this.movieMapper.deleteMovieCommentCount(movie_id);
}
/**
* 添加新的电影信息到数据库。
*
* @param movie 包含要添加的电影信息的 Movie 实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer addMovie(Movie movie) {
return this.movieMapper.addMovie(movie);
}
/**
* 从数据库中删除指定 ID 的电影信息。
*
* @param movie_id 要删除的电影 ID
* @return 如果删除成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer deleteMovie(long movie_id) {
return this.movieMapper.deleteMovie(movie_id);
}
/**
* 更新指定 ID 的电影信息。
*
* @param movie 包含更新信息的 Movie 实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer updateMovie(Movie movie) {
return this.movieMapper.updateMovie(movie);
}
/**
* 根据电影状态查询所有电影信息。
*
* @param movie_state 电影的状态码
* @return 返回包含所有符合条件的电影的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> findAllMovies(int movie_state) {
return this.movieMapper.findAllMovies(movie_state);
}
/**
* 根据电影名称模糊查询电影信息。
*
* @param name 包含要查询的关键字的电影名称
* @return 返回匹配电影名称的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> findMoviesLikeName(String name) {
return this.movieMapper.findMoviesLikeName(name);
}
/**
* 根据电影类型模糊查询电影信息。
*
* @param type 包含要查询的关键字的电影类型
* @return 返回匹配电影类型的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> findMoviesLikeType(String type) {
return this.movieMapper.findMoviesLikeType(type);
}
/**
* 按上映日期对电影进行排序并返回结果。
*
* @return 返回按上映日期排序的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> sortMovieByDate() {
return this.movieMapper.sortMovieByDate();
}
/**
* 按评论数量对电影进行排序并返回结果。
*
* @return 返回按评论数量排序的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> sortMovieByCount() {
return this.movieMapper.sortMovieByCount();
}
/**
* 按评分对电影进行排序并返回结果。
*
* @return 返回按评分排序的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> sortMovieByScore() {
return this.movieMapper.sortMovieByScore();
}
/**
* 按票房对电影进行排序并返回结果。
*
* @return 返回按票房排序的 Movie 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Movie> sortMovieByBoxOffice() {
return this.movieMapper.sortMovieByBoxOffice();
}
}
public class MovieServiceImp implements IMovieService{
@Autowired
private MovieMapper movieMapper;
@Autowired
private CommentMapper commentMapper;
@Autowired
private UserMapper userMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Movie findMovieById(long movie_id) {
Movie movie = this.movieMapper.findMovieById(movie_id);
List<Comment> list = this.commentMapper.findCommentsByMoiveId(movie_id);
for(Comment comment : list) {
comment.setComment_user(this.userMapper.findUserById(comment.getUser_id()));
}
movie.setCommentList(list);
return movie;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer changeMovieBoxOffice(float price, long movie_id) {
return this.movieMapper.changeMovieBoxOffice(price, movie_id);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Movie findMovieByName(String movie_cn_name) {
return this.movieMapper.findMovieByName(movie_cn_name);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addCommentCount(long movie_id) {
return this.movieMapper.addMovieCommentCount(movie_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer delCommentCount(long movie_id) {
return this.movieMapper.deleteMovieCommentCount(movie_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addMovie(Movie movie) {
return this.movieMapper.addMovie(movie);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteMovie(long movie_id) {
return this.movieMapper.deleteMovie(movie_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateMovie(Movie movie) {
return this.movieMapper.updateMovie(movie);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> findAllMovies(int movie_state) {
return this.movieMapper.findAllMovies(movie_state);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> findMoviesLikeName(String name) {
return this.movieMapper.findMoviesLikeName(name);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> findMoviesLikeType(String type) {
return this.movieMapper.findMoviesLikeType(type);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> sortMovieByDate() {
return this.movieMapper.sortMovieByDate();
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> sortMovieByCount() {
return this.movieMapper.sortMovieByCount();
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> sortMovieByScore() {
return this.movieMapper.sortMovieByScore();
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Movie> sortMovieByBoxOffice() {
return this.movieMapper.sortMovieByBoxOffice();
}
}

364
src/main/java/com/service/imp/OrderServiceImp.java
Unescape View File

@ -21,222 +21,150 @@ import com.mapper.ScheduleMapper;
import com.mapper.UserMapper;
import com.service.IOrderService;
/**
* OrderServiceImp类，它实现了IOrderService接口，主要用于处理订单（Order）相关的业务逻辑。
* 此类通过Spring的依赖注入机制获取了多个Mapper对象，包括OrderMapper、UserMapper、ScheduleMapper、HallMapper、MovieMapper以及CinemaMapper等，用于与不同实体对应的数据库表进行交互，以获取或更新相关数据，并且借助Spring的事务管理功能来保障数据操作的一致性和完整性。
* 通过`@Service`注解将该类标记为Spring的服务层组件，方便Spring框架进行管理以及在其他组件中进行依赖注入使用。
*/
@Service
public class OrderServiceImp implements IOrderService {
/**
* 通过Spring的依赖注入自动获取OrderMapper对象，用于调用与订单数据持久化相关的方法，例如查询、插入、更新订单记录等操作，实现与数据库中订单表的交互。
*/
@Autowired
private OrderMapper orderMapper;
/**
* 通过Spring的依赖注入自动获取UserMapper对象，用于调用与用户数据持久化相关的方法，在处理订单业务时，可用于获取订单关联的用户信息，实现与数据库中用户表的交互。
*/
@Autowired
private UserMapper userMapper;
/**
* 通过Spring的依赖注入自动获取ScheduleMapper对象，用于调用与电影场次数据持久化相关的方法，在订单业务中，可获取订单对应的场次信息，实现与数据库中场次表的交互。
*/
@Autowired
private ScheduleMapper scheduleMapper;
/**
* 通过Spring的依赖注入自动获取HallMapper对象，用于调用与放映厅数据持久化相关的方法，配合场次信息进一步获取场次对应的放映厅详情，实现与数据库中放映厅表的交互。
*/
@Autowired
private HallMapper hallMapper;
/**
* 通过Spring的依赖注入自动获取MovieMapper对象，用于调用与电影数据持久化相关的方法，用于获取场次对应的电影信息，实现与数据库中电影表的交互。
*/
@Autowired
private MovieMapper movieMapper;
/**
* 通过Spring的依赖注入自动获取CinemaMapper对象，用于调用与电影院数据持久化相关的方法，在获取放映厅信息后，进一步获取放映厅所属的电影院信息，实现与数据库中电影院表的交互。
*/
@Autowired
private CinemaMapper cinemaMapper;
/**
* 根据订单的唯一标识（ID）查询订单信息的方法。
* 该方法被标记为事务性方法，事务传播行为设置为`Propagation.REQUIRED`，意味着如果当前存在事务，则加入该事务；如果不存在，则创建一个新事务。同时设置为只读事务（`readOnly=true`），因为主要是查询数据，无需修改数据，这样可提高性能并优化数据库资源利用。
* 首先通过OrderMapper的`findOrderById`方法从数据库中获取指定ID的订单基本信息，如果获取到的订单对象不为空，则进行关联信息的设置：通过UserMapper的`findUserById`方法获取订单关联的用户信息并设置到订单对象中；接着获取订单关联的场次信息，再依次获取场次对应的放映厅信息、放映厅所属的电影院信息以及场次对应的电影信息，并将这些关联信息层层设置到相应的对象中，最后返回包含完整关联信息的订单对象；若未获取到订单对象（即订单不存在），则直接返回`null`。
* @param order_id 要查询的订单的唯一标识（通常是一个特定格式的字符串）
* @return 返回一个`Order`对象，代表查询到的订单信息，其中包含了关联的用户、场次、放映厅、电影院以及电影等详细信息，如果未找到对应订单则返回`null`（具体取决于底层Mapper的实现逻辑）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Order findOrderById(String order_id) {
Order order = this.orderMapper.findOrderById(order_id);
if (order!= null) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
} else {
order = null;
}
return order;
}
/**
* 根据用户名查询该用户所有处于申请退票状态的订单信息的方法。
* 该方法同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 首先通过OrderMapper的`findRefundOrderByUserName`方法获取指定用户名对应的申请退票状态的订单列表，如果列表中有订单（即列表大小大于0），则遍历该列表，对每个订单对象进行关联信息的设置，操作与`findOrderById`方法中设置关联信息类似，将用户、场次、放映厅、电影院以及电影等关联信息设置到订单对象中；若列表为空（即没有符合条件的订单），则将列表设置为`null`，最后返回处理后的订单列表。
* @param user_name 要查询其申请退票订单的用户名
* @return 返回一个包含符合条件的`Order`对象的`List`集合，每个对象代表一条申请退票的订单记录信息，且其中包含了关联的用户、场次、放映厅、电影院以及电影等详细信息，可能为空集合（如果该用户没有申请退票的订单）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Order> findRefundOrderByUserName(String user_name) {
List<Order> list = this.orderMapper.findRefundOrderByUserName(user_name);
if (list.size() > 0) {
for (Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
} else {
list = null;
}
return list;
}
/**
* 向数据库中插入一条新的订单记录的方法。
* 此方法是事务性方法，事务传播行为为`Propagation.REQUIRED`，且设置了`rollbackFor=Exception.class`，表示如果方法执行过程中抛出任何异常，都会回滚当前事务，以此保证数据的一致性，确保插入操作要么全部成功，要么全部失败。
* 内部通过调用OrderMapper的`addOrder`方法，将传入的包含订单信息的`Order`对象插入到数据库的订单表中，并返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），用于判断插入操作是否成功。
* @param order 包含要插入的订单信息的`Order`对象
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer addOrder(Order order) {
return this.orderMapper.addOrder(order);
}
/**
* 将指定订单的状态更新为申请退票状态的方法。
* 同样是事务性方法，事务传播行为为`Propagation.REQUIRED`，且设置了`rollbackFor=Exception.class`，保证在更新订单状态出现异常时能正确回滚事务，维持数据的完整性。
* 通过调用OrderMapper的`updateOrderStateToRefund`方法，依据传入的订单唯一标识（order_id）在数据库中找到对应的订单记录，并将其订单状态字段更新为表示申请退票的值（具体值由业务逻辑中约定），然后返回受影响的行数来表明更新操作是否成功执行（一般成功更新返回1，不存在对应记录返回0等情况），用于确认订单状态更新为申请退票这一操作的结果。
* @param order_id 要更新状态为申请退票的订单的唯一标识
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer updateOrderStateToRefund(String order_id) {
return this.orderMapper.updateOrderStateToRefund(order_id);
}
/**
* 将指定订单的状态更新为同意退票状态的方法。
* 也是事务性方法，事务传播行为和异常回滚设置与上述更新为申请退票状态的方法类似，确保更新订单状态为同意退票操作的事务一致性。
* 调用OrderMapper的`updateOrderStateToRefunded`方法，依据传入的订单唯一标识（order_id）在数据库里定位到相应订单记录，把其订单状态字段更新为表示同意退票的值（按照业务逻辑中定义的相应状态值来更新），同样根据更新操作结果返回受影响的行数，用于判断订单状态更新为同意退票这一操作是否成功执行。
* @param order_id 要更新状态为同意退票的订单的唯一标识
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer updateOrderStateToRefunded(String order_id) {
return this.orderMapper.updateOrderStateToRefunded(order_id);
}
/**
* 分页查询指定用户名的订单信息的方法。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 首先通过`PageHelper.startPage(page, limit)`设置分页参数，然后通过OrderMapper的`findOrdersByUserName`方法获取指定用户名的订单列表，接着遍历该列表，为每个订单对象设置关联的用户、场次、放映厅、电影院以及电影等信息，最后将设置好关联信息的订单列表封装到`PageInfo`对象中，`PageInfo`对象包含了分页相关的各种信息（如总记录数、总页数、当前页数据等），便于在前端展示分页效果以及进行相关分页操作的处理，然后返回这个`PageInfo`对象。
* @param page 当前页码，用于指定要获取的是第几页数据
* @param limit 每页显示的记录条数，用于限制每页的数据量
* @param user_name 要查询其订单的用户名
* @return 返回一个`PageInfo<Order>`对象，包含了分页后的指定用户名的订单信息以及分页相关的详细数据
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Order> findOrdersByUserName(Integer page, Integer limit, String user_name) {
PageHelper.startPage(page, limit);
List<Order> list = this.orderMapper.findOrdersByUserName(user_name);
for (Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
PageInfo<Order> info = new PageInfo<Order>(list);
return info;
}
/**
* 查询数据库中所有订单信息的方法。
* 同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 首先通过OrderMapper的`findAllOrders`方法获取所有订单的基本信息列表，然后遍历该列表，为每个订单对象设置关联的用户、场次、放映厅、电影院以及电影等信息，最后返回包含完整关联信息的所有订单列表，方便获取整体的订单及其关联详情情况，例如用于订单数据统计、管理等业务场景。
* @return 返回一个包含所有`Order`对象的`List`集合，每个对象代表一条订单记录信息，且其中包含了关联的用户、场次、放映厅、电影院以及电影等详细信息
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Order> findAllOrders() {
List<Order> list = this.orderMapper.findAllOrders();
for (Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
return list;
}
/**
* 分页查询符合指定状态的订单信息的方法。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 先通过`PageHelper.startPage(page, limit)`设置分页参数，然后通过OrderMapper的`findOrdersByState`方法获取符合指定状态的订单列表，接着遍历该列表，为每个订单对象设置关联的用户、场次、放映厅、电影院以及电影等信息，最后将设置好关联信息的订单列表封装到`PageInfo`对象中返回，便于前端根据状态展示分页的订单列表以及进行相关操作，例如按不同订单状态统计订单数量等业务场景。
* @param page 当前页码，用于指定要获取的是第几页数据
* @param limit 每页显示的记录条数，用于限制每页的数据量
* @param order_state 表示订单状态的整数，用于筛选符合该状态的订单记录
* @return 返回一个`PageInfo<Order>`对象，包含了分页后的符合指定状态的订单信息以及分页相关的详细数据
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Order> findOrdersByState(Integer page, Integer limit, int order_state) {
PageHelper.startPage(page, limit);
List<Order> list = this.orderMapper.findOrdersByState(order_state);
for (Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
PageInfo<Order> info = new PageInfo<Order>(list);
return info;
}
/**
* 分页查询所有订单信息的方法，支持根据关键词筛选订单（如果关键词不为空，则按用户名模糊查询订单）。
* 同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 首先通过`PageHelper.startPage(page, limit)`设置分页参数，然后根据关键词情况决定查询逻辑：如果关键词不为空且去除空格后不为空字符串，就通过OrderMapper的`findOrdersByUserName`方法按用户名进行模糊查询获取订单列表；否则直接通过`findAllOrders`方法获取所有订单列表。接着遍历获取到的订单列表，为每个订单对象设置关联的用户、场次、放映厅、电影院以及电影等信息，最后将设置好关联信息的订单列表封装到`PageInfo`对象中返回，便于前端展示分页的订单列表以及进行相关操作，例如订单搜索功能实现等业务场景。
* @param page 当前页码，用于指定要获取的是第几页数据
* @param limit 每页显示的记录条数，用于限制每页的数据量
* @param keyword 关键词，用于按用户名模糊查询订单，如果为`null`或者空字符串则查询全部订单
* @return 返回一个`PageInfo<Order>`对象，包含了分页后的订单信息以及
public class OrderServiceImp implements IOrderService{
@Autowired
private OrderMapper orderMapper;
@Autowired
private UserMapper userMapper;
@Autowired
private ScheduleMapper scheduleMapper;
@Autowired
private HallMapper hallMapper;
@Autowired
private MovieMapper movieMapper;
@Autowired
private CinemaMapper cinemaMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Order findOrderById(String order_id) {
Order order = this.orderMapper.findOrderById(order_id);
if(order != null) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}else {
order = null;
}
return order;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Order> findRefundOrderByUserName(String user_name) {
List<Order> list = this.orderMapper.findRefundOrderByUserName(user_name);
if(list.size() > 0) {
for(Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
}else {
list = null;
}
return list;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addOrder(Order order) {
return this.orderMapper.addOrder(order);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateOrderStateToRefund(String order_id) {
return this.orderMapper.updateOrderStateToRefund(order_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateOrderStateToRefunded(String order_id) {
return this.orderMapper.updateOrderStateToRefunded(order_id);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Order> findOrdersByUserName(Integer page,Integer limit,String user_name) {
PageHelper.startPage(page, limit);
List<Order> list = this.orderMapper.findOrdersByUserName(user_name);
for(Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
PageInfo<Order> info = new PageInfo<Order>(list);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Order> findAllOrders() {
List<Order> list = this.orderMapper.findAllOrders();
for(Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
return list;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Order> findOrdersByState(Integer page,Integer limit,int order_state) {
PageHelper.startPage(page, limit);
List<Order> list = this.orderMapper.findOrdersByState(order_state);
for(Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
PageInfo<Order> info = new PageInfo<Order>(list);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Order> findAllOrdersBySplitPage(Integer page, Integer limit, String keyword) {
PageHelper.startPage(page, limit);
List<Order> list = new ArrayList<Order>();
if(keyword != null && !keyword.trim().equals("")) {
list = this.orderMapper.findOrdersByUserName(keyword);
}else {
list = this.orderMapper.findAllOrders();
}
for(Order order : list) {
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
PageInfo<Order> info = new PageInfo<Order>(list);
return info;
}
}

378
src/main/java/com/service/imp/ScheduleServiceImp.java
Unescape View File

@ -20,231 +20,153 @@ import com.mapper.ScheduleMapper;
import com.service.IScheduleService;
@Service
public class ScheduleServiceImp implements IScheduleService {
@Autowired
private ScheduleMapper scheduleMapper; // 依赖注入 ScheduleMapper 用于执行与排片相关的数据库操作
@Autowired
private HallMapper hallMapper; // 依赖注入 HallMapper 用于执行与影厅相关的数据库操作
@Autowired
private MovieMapper movieMapper; // 依赖注入 MovieMapper 用于执行与电影相关的数据库操作
@Autowired
private OrderMapper orderMapper; // 依赖注入 OrderMapper 用于执行与订单相关的数据库操作
@Autowired
private CinemaMapper cinemaMapper; // 依赖注入 CinemaMapper 用于执行与影院相关的数据库操作
/**
* 根据排片 ID 查询单个排片信息，并加载关联的影厅、影院、电影和订单列表。
*
* @param schedule_id 要查询的排片 ID
* @return 返回包含排片及其关联信息的 Schedule 实体对象；如果未找到，则返回 null
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public Schedule findScheduleById(long schedule_id) {
Schedule schedule = this.scheduleMapper.findScheduleById(schedule_id);
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id())); // 设置影厅所属的影院
schedule.setSchedule_hall(hall); // 设置排片的影厅
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id())); // 设置排片的电影
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule_id);
schedule.setOrderList(list); // 设置排片的订单列表
return schedule;
}
/**
* 添加新的排片信息到数据库。
*
* @param schedule 包含要添加的排片信息的 Schedule 实体对象
* @return 如果插入成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer addSchedule(Schedule schedule) {
return this.scheduleMapper.addSchedule(schedule);
}
/**
* 更新指定 ID 的排片信息。
*
* @param schedule 包含更新信息的 Schedule 实体对象
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer updateSchedule(Schedule schedule) {
return this.scheduleMapper.updateSchedule(schedule);
}
/**
* 将指定 ID 的排片下架（而非物理删除）。
*
* @param schedule_id 要下架的排片 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer deleteSchedule(long schedule_id) {
return this.scheduleMapper.deleteSchedule(schedule_id);
}
/**
* 增加指定排片的剩余座位数。
*
* @param schedule_id 要增加剩余座位数的排片 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer addScheduleRemain(long schedule_id) {
return this.scheduleMapper.addScheduleRemain(schedule_id);
}
/**
* 减少指定排片的剩余座位数。
*
* @param schedule_id 要减少剩余座位数的排片 ID
* @return 如果更新成功，返回受影响的行数（通常为1）；否则返回0
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作，遇到异常时回滚
@Override
public Integer delScheduleRemain(long schedule_id) {
return this.scheduleMapper.delScheduleRemain(schedule_id);
}
/**
* 根据电影名称分页查询排片信息，并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param movie_name 电影名称
* @return 返回包含分页信息的 PageInfo 对象
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public PageInfo<Schedule> findScheduleByMovieName(Integer page, Integer limit, String movie_name) {
PageHelper.startPage(page, limit); // 启用分页
List<Schedule> schedules = this.scheduleMapper.findScheduleByMovieName(movie_name);
for (Schedule schedule : schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id())); // 设置影厅所属的影院
schedule.setSchedule_hall(hall); // 设置排片的影厅
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id())); // 设置排片的电影
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list); // 设置排片的订单列表
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
return info;
}
/**
* 根据电影名称分页查询已下架的排片信息，并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param movie_name 电影名称
* @return 返回包含分页信息的 PageInfo 对象
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public PageInfo<Schedule> findOffScheduleByMovieName(Integer page, Integer limit, String movie_name) {
PageHelper.startPage(page, limit); // 启用分页
List<Schedule> schedules = this.scheduleMapper.findOffScheduleByMovieName(movie_name);
for (Schedule schedule : schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id())); // 设置影厅所属的影院
schedule.setSchedule_hall(hall); // 设置排片的影厅
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id())); // 设置排片的电影
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list); // 设置排片的订单列表
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
return info;
}
/**
* 根据排片状态分页查询排片信息，并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @param schedule_state 排片状态码
* @return 返回包含分页信息的 PageInfo 对象
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public PageInfo<Schedule> findAllScheduleByState(Integer page, Integer limit, int schedule_state) {
PageHelper.startPage(page, limit); // 启用分页
List<Schedule> schedules = this.scheduleMapper.findScheduleByState(schedule_state);
for (Schedule schedule : schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id())); // 设置影厅所属的影院
schedule.setSchedule_hall(hall); // 设置排片的影厅
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id())); // 设置排片的电影
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list); // 设置排片的订单列表
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
return info;
}
/**
* 分页查询所有排片信息，并加载关联的影厅、影院、电影和订单列表。
*
* @param page 当前页码
* @param limit 每页显示的记录数
* @return 返回包含分页信息的 PageInfo 对象
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public PageInfo<Schedule> findAllSchedule(Integer page, Integer limit) {
PageHelper.startPage(page, limit); // 启用分页
List<Schedule> schedules = this.scheduleMapper.findAllSchedule();
for (Schedule schedule : schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id())); // 设置影厅所属的影院
schedule.setSchedule_hall(hall); // 设置排片的影厅
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id())); // 设置排片的电影
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list); // 设置排片的订单列表
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
return info;
}
/**
* 根据影院 ID 和电影 ID 查询排片信息。
*
* @param cinema_id 影院 ID
* @param movie_id 电影 ID
* @return 返回符合条件的 Schedule 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Schedule> findScheduleByCinemaAndMovie(long cinema_id, long movie_id) {
return this.scheduleMapper.findScheduleByCinemaAndMovie(cinema_id, movie_id);
}
/**
* 为 selectSeat 页面提供接口，根据影院 ID 和电影 ID 查询排片信息，并加载关联的影厅、影院和电影。
*
* @param cinema_id 影院 ID
* @param movie_id 电影 ID
* @return 返回符合条件的 Schedule 实体对象列表
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作，不需要回滚
@Override
public List<Schedule> findScheduleByCineamIdAndMovieId(long cinema_id, long movie_id) {
List<Schedule> list = this.scheduleMapper.findScheduleByCinemaAndMovie(cinema_id, movie_id);
for (Schedule schedule : list) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id())); // 设置影厅所属的影院
schedule.setSchedule_hall(hall); // 设置排片的影厅
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id())); // 设置排片的电影
}
return list;
}
}
public class ScheduleServiceImp implements IScheduleService{
@Autowired
private ScheduleMapper scheduleMapper;
@Autowired
private HallMapper hallMapper;
@Autowired
private MovieMapper movieMapper;
@Autowired
private OrderMapper orderMapper;
@Autowired
private CinemaMapper cinemaMapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public Schedule findScheduleById(long schedule_id) {
Schedule schedule = this.scheduleMapper.findScheduleById(schedule_id);
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule_id);
schedule.setOrderList(list);
return schedule;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addSchedule(Schedule schedule) {
return this.scheduleMapper.addSchedule(schedule);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateSchedule(Schedule schedule) {
return this.scheduleMapper.updateSchedule(schedule);
}
/**
* 场次下架功能 而非删除
*/
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteSchedule(long schedule_id) {
return this.scheduleMapper.deleteSchedule(schedule_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addScheduleRemain(long schedule_id) {
return this.scheduleMapper.addScheduleRemain(schedule_id);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer delScheduleRemain(long schedule_id) {
return this.scheduleMapper.delScheduleRemain(schedule_id);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Schedule> findScheduleByMovieName(Integer page,Integer limit,String movie_name) {
PageHelper.startPage(page, limit);
List<Schedule> schedules = this.scheduleMapper.findScheduleByMovieName(movie_name);
for(Schedule schedule: schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Schedule> findOffScheduleByMovieName(Integer page, Integer limit, String movie_name) {
PageHelper.startPage(page, limit);
List<Schedule> schedules = this.scheduleMapper.findOffScheduleByMovieName(movie_name);
for(Schedule schedule: schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Schedule> findAllScheduleByState(Integer page,Integer limit,int schedule_state) {
PageHelper.startPage(page, limit);
List<Schedule> schedules = this.scheduleMapper.findScheduleByState(schedule_state);
for(Schedule schedule: schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<Schedule> findAllSchedule(Integer page,Integer limit) {
PageHelper.startPage(page, limit);
List<Schedule> schedules = this.scheduleMapper.findAllSchedule();
for(Schedule schedule: schedules) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule.getSchedule_id());
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Schedule> findScheduleByCinemaAndMovie(long cinema_id, long movie_id) {
return this.scheduleMapper.findScheduleByCinemaAndMovie(cinema_id, movie_id);
}
/**
* selectSeat页面提供接口
*/
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Schedule> findScheduleByCineamIdAndMovieId(long cinema_id, long movie_id) {
List<Schedule> list = this.scheduleMapper.findScheduleByCinemaAndMovie(cinema_id, movie_id);
for(Schedule schedule: list) {
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
schedule.setSchedule_hall(hall);
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
}
return list;
}
}

214
src/main/java/com/service/imp/UserServiceImp.java
Unescape View File

@ -14,150 +14,80 @@ import com.github.pagehelper.PageInfo;
import com.mapper.UserMapper;
import com.service.IUserService;
/**
* UserServiceImp类，它实现了IUserService接口，主要用于处理用户（User）相关的业务逻辑。
* 通过依赖注入获取UserMapper对象，进而调用其对应的数据库操作方法，与数据库中的用户表进行交互，实现诸如用户登录验证、信息查询、修改、新增以及删除等功能，同时利用Spring的事务管理特性来保障数据操作的一致性和完整性。
* 使用`@Service`注解将该类标记为Spring的服务层组件，便于Spring框架进行管理以及在其他组件中进行依赖注入使用。
*/
@Service
public class UserServiceImp implements IUserService {
public class UserServiceImp implements IUserService{
/**
* 通过Spring的依赖注入机制自动注入UserMapper对象，用于调用与用户数据持久化相关的方法，例如查询用户信息、更新用户记录、插入新用户以及删除用户等操作，实现与数据库中用户表的交互。
*/
@Autowired
private UserMapper usermapper;
@Autowired
private UserMapper usermapper;
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public User login(String user_name, String user_pwd) {
List<User> userList = usermapper.findUserByName(user_name);
for(User user : userList) {
if(user.getUser_pwd().equals(user_pwd)) {
return user;
}
}
return null;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateUserInfo(User user) {
return this.usermapper.updateUser(user);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public User findUserById(long user_id) {
return this.usermapper.findUserById(user_id);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<User> findUserByName(String name) {
return this.usermapper.findUserByName(name);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer addUser(User user) {
return this.usermapper.addUser(user);
}
/**
* 用户登录验证的方法，用于验证输入的用户名和密码是否匹配，从而判断用户能否成功登录。
* 该方法被标记为事务性方法，事务传播行为设置为`Propagation.REQUIRED`，表示如果当前存在事务，则加入该事务；如果不存在，则创建一个新事务，同时设置为只读事务（`readOnly = true`），因为只是进行数据查询验证，不需要修改数据，这样可提高性能并优化数据库资源利用。
* 首先通过UserMapper的`findUserByName`方法根据传入的用户名从数据库中查询获取对应的用户信息列表，然后遍历该列表，对比每个用户对象的密码与传入的密码是否一致，若找到匹配的密码，则返回对应的用户对象，表示登录验证成功；若遍历完列表都未找到匹配密码的用户，则返回`null`，表示登录验证失败。
* @param user_name 要登录的用户名，用于在数据库中查找对应的用户记录
* @param user_pwd 要登录的用户输入的密码，用于与数据库中查询到的用户记录密码进行比对验证
* @return 返回一个`User`对象，表示登录验证成功的用户信息，如果验证失败则返回`null`
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public User login(String user_name, String user_pwd) {
List<User> userList = usermapper.findUserByName(user_name);
for (User user : userList) {
if (user.getUser_pwd().equals(user_pwd)) {
return user;
}
}
return null;
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteUser(long user_id) {
return this.usermapper.deleteUser(user_id);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public PageInfo<User> findAllUserBySplitPage(Integer page, Integer limit, String keyword) {
PageHelper.startPage(page, limit);
List<User> list = new ArrayList<User>();
if(keyword != null && !keyword.trim().equals("")) {
list = this.usermapper.findUserLikeName(keyword);
}else {
list = this.usermapper.findAllUser();
}
PageInfo<User> info = new PageInfo<User>(list);
return info;
}
/**
* 根据传入的用户对象信息更新数据库中对应的用户记录的方法。
* 此方法是事务性方法，事务传播行为为`Propagation.REQUIRED`，且设置了`rollbackFor = Exception.class`，意味着如果方法执行过程中抛出任何异常，都会回滚当前事务，以此保证数据的一致性，确保更新操作要么全部成功，要么全部失败，避免出现数据不一致的情况。
* 通过调用UserMapper的`updateUser`方法，依据传入的用户对象的属性值来更新数据库里对应用户记录的相应字段，然后返回受影响的行数，用于判断更新操作是否成功执行（通常更新成功返回1，失败返回0等，具体依数据库执行情况而定）。
* @param user 包含更新后用户信息的`User`对象，其属性值将用于更新数据库中对应的用户记录
* @return 返回一个`Integer`类型的值，表示更新操作影响的行数，可用于判断更新是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer updateUserInfo(User user) {
return this.usermapper.updateUser(user);
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<User> findAllUserInfos() {
return this.usermapper.findAllUser();
}
/**
* 根据用户的唯一标识（ID）从数据库中查询获取对应的用户信息的方法。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 内部直接调用UserMapper的`findUserById`方法，依据传入的用户ID从数据库中查找对应的用户记录，并返回查询到的用户对象，方便获取特定用户的详细信息，例如在展示用户个人资料等场景中使用。
* @param user_id 要查询的用户的唯一标识（通常是一个具有特定格式的数字）
* @return 返回一个`User`对象，代表查询到的用户信息，如果未找到对应用户则返回`null`（具体取决于底层Mapper的实现逻辑）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public User findUserById(long user_id) {
return this.usermapper.findUserById(user_id);
}
/**
* 根据用户名从数据库中查询获取对应的用户信息列表的方法。
* 同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 直接调用UserMapper的`findUserByName`方法，依据传入的用户名从数据库中查找匹配的用户记录，并以列表形式返回所有符合条件的用户对象集合，方便在业务逻辑中根据用户名查找用户信息，例如在用户搜索等功能中使用。
* @param name 要查询的用户名，用于在数据库中筛选出对应的用户记录
* @return 返回一个包含符合条件的`User`对象的`List`集合，每个对象代表一条匹配用户名的用户记录信息，可能为空集合（如果没有找到对应用户名的用户）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<User> findUserByName(String name) {
return this.usermapper.findUserByName(name);
}
/**
* 向数据库中插入一条新的用户记录的方法。
* 也是事务性方法，事务传播行为为`Propagation.REQUIRED`，且设置了`rollbackFor = Exception.class`，保证在插入用户记录过程中如果出现异常，能够回滚事务，确保数据的一致性，即插入操作要完整执行，不能出现部分数据插入成功而部分失败的情况。
* 通过调用UserMapper的`addUser`方法，将传入的包含新用户信息的`User`对象插入到数据库的用户表中，并返回受影响的行数（通常插入成功返回1，失败返回0等，具体依数据库执行情况而定），用于判断插入操作是否成功。
* @param user 包含要插入的新用户信息的`User`对象，其属性值将被插入到数据库的用户表对应字段中
* @return 返回一个`Integer`类型的值，表示插入操作影响的行数，可用于判断插入是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer addUser(User user) {
return this.usermapper.addUser(user);
}
/**
* 根据用户的唯一标识（ID）从数据库中删除对应的用户记录的方法。
* 同样是事务性方法，事务传播行为和异常回滚设置与上述插入、更新方法类似，确保删除操作的事务一致性，防止出现数据不一致的情况，例如误删或者删除操作执行一半等问题。
* 调用UserMapper的`deleteUser`方法，依据传入的用户ID从数据库用户表中移除对应的记录，并返回受影响的行数来表明删除操作是否成功执行（一般成功删除返回1，不存在对应记录返回0等情况）。
* @param user_id 要删除的用户的唯一标识
* @return 返回一个`Integer`类型的值，表示删除操作影响的行数，可用于判断删除是否成功
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer deleteUser(long user_id) {
return this.usermapper.deleteUser(user_id);
}
/**
* 分页查询所有用户信息的方法，支持根据关键词进行模糊查询（如果关键词不为空，则按用户名模糊查询用户）。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 首先通过`PageHelper.startPage(page, limit)`设置分页参数，然后根据关键词情况决定查询逻辑：如果关键词不为空且去除空格后不为空字符串，就调用UserMapper的`findUserLikeName`方法按用户名进行模糊查询获取用户列表；否则直接调用`findAllUser`方法获取所有用户列表。最后将获取到的用户列表封装到`PageInfo`对象中，`PageInfo`对象包含了分页相关的各种信息（如总记录数、总页数、当前页数据等），便于在前端展示分页效果以及进行相关分页操作的处理，然后返回这个`PageInfo`对象。
* @param page 当前页码，用于指定要获取的是第几页数据
* @param limit 每页显示的记录条数，用于限制每页的数据量
* @param keyword 关键词，用于按用户名模糊查询用户，如果为`null`或者空字符串则查询全部用户
* @return 返回一个`PageInfo<User>`对象，包含了分页后的用户信息以及分页相关的详细数据
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<User> findAllUserBySplitPage(Integer page, Integer limit, String keyword) {
PageHelper.startPage(page, limit);
List<User> list = new ArrayList<User>();
if (keyword!= null &&!keyword.trim().equals("")) {
list = this.usermapper.findUserLikeName(keyword);
} else {
list = this.usermapper.findAllUser();
}
PageInfo<User> info = new PageInfo<User>(list);
return info;
}
/**
* 查询数据库中所有用户信息的方法。
* 同样是事务性且只读的方法，事务传播行为为`Propagation.REQUIRED`。
* 内部直接调用UserMapper的`findAllUser`方法从数据库中获取所有用户记录，并以列表形式返回所有用户对象集合，方便获取整体的用户信息情况，例如用于用户数据统计、管理等业务场景。
* @return 返回一个包含所有`User`对象的`List`集合，每个对象代表一条用户记录信息
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<User> findAllUserInfos() {
return this.usermapper.findAllUser();
}
/**
* 根据用户名进行模糊查询获取用户信息列表的方法。
* 该方法设置为事务性且只读，事务传播行为为`Propagation.REQUIRED`。
* 直接调用UserMapper的`findUserLikeName`方法，依据传入的用户名利用模糊查询（通常使用`LIKE`关键字结合通配符在数据库中进行匹配）从数据库中查找符合条件的用户记录，并以列表形式返回所有匹配的用户对象集合，方便在业务逻辑中进行模糊搜索用户等功能实现。
* @param name 要进行模糊查询的用户名，用于在数据库中筛选出符合模糊条件的用户记录
* @return 返回一个包含符合模糊查询条件的`User`对象的`List`集合，可能为空集合（如果没有找到符合条件的用户）
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<User> findUserLikeName(String name) {
return this.usermapper.findUserLikeName(name);
}
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<User> findUserLikeName(String name) {
return this.usermapper.findUserLikeName(name);
}
}

271
src/main/java/com/util/test.java
Unescape View File

@ -9,171 +9,110 @@ import java.util.Random;
import com.alibaba.fastjson.JSONObject;
// 定义名为test的公共类，属于com.util包
public class test {
// Java程序的入口方法，程序从这里开始执行
public static void main(String[] args) {
// 创建一个Date对象，表示当前日期和时间
// Date date = new Date();
// 使用Date对象的年、月、日信息创建一个java.sql.Date对象（注：此处代码存在问题，构造方法参数已过时，推荐使用 Calendar 或者直接传入毫秒值等方式来正确创建 java.sql.Date，这里暂按原代码注释逻辑说明）
// java.sql.Date zdate = new java.sql.Date(date.getYear(), date.getMonth(), date.getDay());
// 输出原始的Date对象，展示完整日期时间信息
// System.out.println(date);
// 输出转换后的java.sql.Date对象（按照上述有问题的方式构造出来的）
// System.out.println(zdate);
// 循环20次生成并格式化随机数
// for(int i = 0;i<20;i++) {
// 生成一个范围在5到9（包含5，不包含9）之间的随机浮点数
// float random = 5 + (new Random().nextFloat() * 4);
// 创建一个DecimalFormat对象，用于格式化数字，格式化为保留一位小数的形式
// DecimalFormat fnum = new DecimalFormat("##0.0");
// 使用DecimalFormat对象将随机数格式化为字符串
// String score = fnum.format(random);
// 下面这行被注释掉了，原本功能是将随机数直接转换为字符串（与上面格式化后转字符串的方式不同）
// String rs = String.valueOf(random);
// 输出格式化后的随机数字符串，前面添加了"score:"标识
// System.out.println("score:" + score);
// }
// 创建一个空的JSONObject对象，用于存储和操作JSON格式的数据
// JSONObject obj = new JSONObject();
// 创建另一个空的JSONObject对象，可能用于存储影院相关信息（从后续代码推测）
// JSONObject hallobj = new JSONObject();
// 下面这行被注释掉了，原本是想创建一个用于存储影院名称列表的ArrayList，但是由于后续在循环内又重复创建同名变量，所以这里可以考虑删除或者调整使用方式
// ArrayList<String> cinemalist= new ArrayList<String>();
// 外层循环，循环2次，可能用于模拟2个不同的情况（从代码推测可能与影院相关）
// for(int i = 0; i < 2;i++) {
// 在每次外层循环中重新创建一个ArrayList，用于存储影院的厅信息（这里重新创建可能不太合理，除非每次循环都需要全新的列表，否则可以考虑移到循环外创建一次即可）
ArrayList<String> cinemalist= new ArrayList<String>();
// 内层循环，循环2次，用于向当前影院的厅信息列表中添加厅名称（格式为"X号厅"）
for(int j=0;j<2;j++) {
cinemalist.add(String.valueOf(j+1)+"号厅");
}
// 将当前影院的厅信息列表添加到hallobj这个JSONObject中，键为"影院X"（X为当前外层循环的索引值）
hallobj.put("影院"+String.valueOf(i),cinemalist);
// }
// 将包含影院厅信息的hallobj对象添加到obj这个总的JSONObject中，键为"cinema"
obj.put(" cinema ", hallobj);
// 输出整个JSON对象，查看构建好的包含影院信息的JSON结构
System.out.println(obj);
// 从obj中获取键为"cinema"的JSONObject对象（也就是前面存放影院厅信息的那个对象）
JSONObject obj2 = obj.getJSONObject("cinema");
// 输出获取到的二级JSONObject对象（主要是为了查看解析一层后的内容，可能用于调试等目的）
System.out.println(obj2);
// 解析二级，创建一个新的ArrayList，用于存储从JSON中获取的具体影院的厅信息（从后续代码看是获取"影院0"对应的厅列表）
ArrayList<String> halllist= new ArrayList<String>();
// 从obj2中获取键为"影院0"的值（是一个ArrayList<String>类型）并赋值给halllist，然后可以进一步操作这个列表
halllist = (ArrayList<String>)obj2.get("影院0");
// 输出获取到的厅列表中的第一个元素（主要是示例如何获取具体的厅名称信息）
System.out.println(halllist.get(0));
// 创建一个用于存储整数的ArrayList对象
ArrayList<Integer> arr = new ArrayList<Integer>();
// 循环5次，向ArrayList中添加从0到4的整数
for(int i = 0;i < 5;i++) {
arr.add(i);
}
// 输出ArrayList中索引为4的元素（也就是最后一个添加进去的元素，值为4）
System.out.println(arr.get(4));
// 创建一个Date对象，表示当前日期和时间
Date date = new Date();
// 创建一个SimpleDateFormat对象，用于格式化日期，格式为"YYYYMMdd"（注：这里格式应该是"yyyyMMdd"，大写的"YYYY"表示周年，不符合常规日期格式化需求，不过先按原代码注释逻辑说明）
SimpleDateFormat dateFormat = new SimpleDateFormat("YYYYMMdd");
// 创建一个空字符串，用于后续拼接格式化后的日期字符串
String str = "";
// 将格式化后的日期字符串拼接到str上
str += dateFormat.format(date);
// 输出拼接后的日期字符串
System.out.println(str);
// 定义一个字符串数组，里面存放了一些座位相关的字符串信息（格式类似"X排X座"）
String [] str = {"3排4座","10排1座","5排12座","11排12座"};
// 创建一个ArrayList，用于存储处理后的座位索引相关字符串（从后续代码看是对座位字符串进行格式化转换后的结果）
ArrayList<String> arr = new ArrayList<String>();
// 循环遍历座位字符串数组
for(int i = 0;i < str.length;i++) {
// 下面这行被注释掉了，原本可能是想输出每个座位字符串的长度，用于调试查看情况
// System.out.println(str[i].length());
// 创建一个空字符串，用于后续构建处理后的座位索引字符串
String index = "";
// 根据座位字符串的长度进行不同的处理（目的可能是将座位信息转换为统一格式的索引字符串）
switch(str[i].length()) {
// 如果座位字符串长度为4，进行如下处理（替换"排"为"0"，去掉"座"字符等操作来构建索引字符串）
case 4:
index = "0" + str[i].replaceAll("排", "0");
index = index.replaceAll("座", "");
break;
// 如果座位字符串长度为5，再根据中间字符是否是数字进行不同的替换操作来构建索引字符串
case 5:
if(str[i].charAt(2) >= 48 && str[i].charAt(2) <= 57) {
index = "0" + str[i].replaceAll("排", "");
index = index.replaceAll("座", "");
}else {
index = str[i].replaceAll("排", "0");
index = index.replaceAll("座", "");
}
break;
// 如果座位字符串长度为6，进行简单的替换操作构建索引字符串（去掉"排"和"座"字符）
case 6:
index = str[i].replaceAll("排", "");
index = index.replaceAll("座", "");
break;
}
// 将处理好的索引字符串添加到ArrayList中
arr.add(index);
}
// 输出存储处理后座位索引字符串的ArrayList
System.out.println(arr);
// 下面这行被注释掉了，定义一个整数变量表示价格，值为29（可能是用于后续价格相关计算等用途）
// int price = 29;
// 下面这行被注释掉了，将价格除以10000转换为以万为单位的浮点数（可能是用于统计价格相关数据等情况）
// float box = (float)price /10000;
// 下面这行被注释掉了，输出以万为单位的价格浮点数（同样是和价格转换相关的输出操作）
// System.out.println((float)price /10000);;
// 创建一个DecimalFormat对象，用于格式化数字，格式化为保留四位小数的形式（不过从前面代码看，这里的random变量未定义，应该是代码编写遗漏或者错误，暂按格式相关功能注释）
// DecimalFormat fnum = new DecimalFormat("##0.0000");
// 使用DecimalFormat对象将随机数格式化为字符串（同样由于random未定义，这行实际无法正确执行，仅按功能意图注释）
// String score = fnum.format(random);
public class test {
// 创建一个空的用于存储整数的ArrayList对象
ArrayList<Integer> arr = new ArrayList<>();
// 创建另一个空的用于存储整数索引的ArrayList对象（从后续代码看是用于记录值为0的元素索引）
ArrayList<Integer> indexz = new ArrayList<>();
// 定义一个整数数组，包含了一些整数值（包含0元素）
int num[] = {1,2,3,0,5,0,6};
// 循环将整数数组中的元素添加到arr这个ArrayList中
for(int i = 0;i<num.length;i++) {
arr.add(num[i]);
}
// 循环遍历arr这个ArrayList，查找值为0的元素，并将其索引添加到indexz这个ArrayList中
for(int z = 0;z<arr.size();z++) {
if(arr.get(z) == 0) {
indexz.add(z);
}
}
// 输出存储了所有元素的arr这个ArrayList
System.out.println(arr);
// 输出存储了值为0的元素索引的indexz这个ArrayList
System.out.println(indexz);
// 下面这行被注释掉了，如果取消注释，会移除arr中索引为3的元素（可能是一种操作元素的尝试，暂被注释掉了）
// arr.remove(3);
// 循环遍历indexz这个存储了值为0元素索引的ArrayList
for(int y =0;y<indexz.size();y++) {
// 定义一个临时变量，初始值为0（从后续代码看可能用于调整移除元素时的索引计算，不过代码逻辑有点复杂且可能不太准确，暂按原代码注释逻辑说明）
int test = 0;
// 计算要移除元素的实际索引，用indexz中获取的索引减去test的值（这里test的使用方式有点奇怪，可能导致索引计算错误等问题）
int index = (indexz.get(y))-test;
// 输出要移除元素的索引（可能用于调试查看计算的索引是否正确）
System.out.println(index);
// 根据计算出的索引移除arr中的元素
arr.remove(index);
// 将test的值增加2（同样，这个操作的目的不太明确，可能会导致后续索引计算混乱等问题，代码逻辑可能需要调整）
test = test + 2;
}
// 输出经过移除操作后的arr这个ArrayList（查看最终的元素情况）
System.out.println(arr);
}
}
public static void main(String[] args) {
// Date date = new Date();
// java.sql.Date zdate = new java.sql.Date(date.getYear(), date.getMonth(), date.getDay());
// System.out.println(date);
// System.out.println(zdate);
// for(int i = 0;i<20;i++) {
// float random = 5 + (new Random().nextFloat() * 4);
// DecimalFormat fnum = new DecimalFormat("##0.0");
// String score = fnum.format(random);
// //String rs = String.valueOf(random);
// System.out.println("score:" + score);
// }
// JSONObject obj = new JSONObject();
// JSONObject hallobj = new JSONObject();
// //ArrayList<String> cinemalist= new ArrayList<String>();
// for(int i = 0; i < 2;i++) {
// ArrayList<String> cinemalist= new ArrayList<String>();
// for(int j=0;j<2;j++) {
// cinemalist.add(String.valueOf(j+1)+"号厅");
// }
// hallobj.put("影院"+String.valueOf(i),cinemalist);
// }
// obj.put("cinema", hallobj);
// System.out.println(obj);
// JSONObject obj2 = obj.getJSONObject("cinema");
// //解析 1级
// System.out.println(obj2);
// //解析 2级
// ArrayList<String> halllist= new ArrayList<String>();
// halllist = (ArrayList<String>)obj2.get("影院0");
// System.out.println(halllist.get(0));
// ArrayList<Integer> arr = new ArrayList<Integer>();
// for(int i = 0;i < 5;i++) {
// arr.add(i);
// }
// System.out.println(arr.get(4));
// Date date = new Date();
// SimpleDateFormat dateFormat = new SimpleDateFormat("YYYYMMdd");
// String str = "";
// str += dateFormat.format(date);
// System.out.println(str);
// String [] str = {"3排4座","10排1座","5排12座","11排12座"};
// ArrayList<String> arr = new ArrayList<String>();
// for(int i = 0;i < str.length;i++) {
// //System.out.println(str[i].length());
// String index = "";
// switch(str[i].length()) {
// case 4:
// index = "0" + str[i].replaceAll("排", "0");
// index = index.replaceAll("座", "");
// break;
// case 5:
// if(str[i].charAt(2) >= 48 && str[i].charAt(2) <= 57) {
// index = "0" + str[i].replaceAll("排", "");
// index = index.replaceAll("座", "");
// }else {
// index = str[i].replaceAll("排", "0");
// index = index.replaceAll("座", "");
// }
// break;
// case 6:
// index = str[i].replaceAll("排", "");
// index = index.replaceAll("座", "");
// break;
// }
// arr.add(index);
// }
// System.out.println(arr);
//int price = 29;
//float box = (float)price /10000;
//System.out.println((float)price /10000);;
// DecimalFormat fnum = new DecimalFormat("##0.0000");
// String score = fnum.format(random);
ArrayList<Integer> arr = new ArrayList<>();
ArrayList<Integer> indexz = new ArrayList<>();
int num[] = {1,2,3,0,5,0,6};
for(int i = 0;i<num.length;i++) {
arr.add(num[i]);
}
for(int z = 0;z<arr.size();z++) {
if(arr.get(z) == 0) {
indexz.add(z);
}
}
System.out.println(arr);
System.out.println(indexz);
// arr.remove(3);
for(int y =0;y<indexz.size();y++) {
int test = 0;
int index = (indexz.get(y))-test;
System.out.println(index);
arr.remove(index);
test = test + 2;
}
System.out.println(arr);
}
}

67
src/main/webapp/jsp/login.jsp
Unescape View File

@ -3,26 +3,16 @@
<!DOCTYPE html>
<html>
<head>
<!-- 设置页面的字符编码为UTF-8 -->
<meta charset="UTF-8">
<!-- 确保页面在移动设备上正确显示，初始缩放比例为1.0 -->
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<!-- 兼容IE浏览器的特定模式 -->
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<!-- 引入Bootstrap的最小化样式文件 -->
<link href="../static/bootstrap/css/bootstrap.min.css" rel="stylesheet">
<!-- 引入Bootstrap的样式文件（可能用于开发调试等，一般生产环境用.min版本） -->
<link href="../static/bootstrap/css/bootstrap.css" rel="stylesheet">
<!-- 引入jQuery库的最小化版本，用于操作DOM等功能 -->
<script src="../static/bootstrap/js/jquery-3.3.1.min.js"></script>
<!-- 引入Bootstrap的最小化JavaScript文件，用于实现Bootstrap相关组件功能 -->
<script src="../static/bootstrap/js/bootstrap.min.js"></script>
<!-- 引入自定义的Api.js文件，可能包含项目相关的接口调用等功能 -->
<script src="../static/js/Api.js"></script>
<!-- 设置页面的图标 -->
<link rel="icon" type="image/x-icon" href="../static/images/logo.ico"/>
<!-- 引入自定义的登录页面样式文件 -->
<link href="../static/css/login.css" rel="stylesheet">
<script></script>
@ -30,22 +20,21 @@
</head>
<body>
<!-- 页面中的一个区域，用于展示一些宣传性的元素，如logo、标题等 -->
<!-- ------------------------------------------------------------------- -->
<div class="screen">
<img class="big_logo"><br/>
<label class="title">鹰 眼 电 影</label><br/>
<label class="ineer_one">回首向来风雨茶香里</label><br/>
<label class="ineer_two">眸中一点可是思念谁</label>
</div>
<!-- 登录页的整体内容区域 -->
<!-- 登录页 -->
<div class="content" style="float: left;">
<!-- 用于切换登录和注册的tab栏 -->
<ul class="tab">
<li class="login">登录</li>
<li class="register">注册</li>
</ul>
<div class="page">
<!-- 登录界面的具体内容 -->
<!-- 登录界面 -->
<div class="childpage" style="display: block">
<div>
<label class="login_title">用户登录</label><br/>
@ -70,7 +59,7 @@
<label class="login_version">@版权所有</label>
</div>
</div>
<!-- 注册界面的具体内容 -->
<!-- 注册界面 -->
<div class="childpage" style="display: none">
<div>
<label class="register_title">用户注册</label><br/>
@ -108,14 +97,15 @@
</div>
<!-- ------------------------------------------------------------------- -->
<script>
// 页面加载完成后执行的初始化函数
//初始化
window.onload = function(){
initWindow(); // 初始化登录框位置
initLogin(); // 初始化登录界面
initWindow(); //初始化登录框位置
initLogin(); //初始化登录界面
　　};
// 初始化登录框位置（使其垂直居中、水平处于页面特定位置）
//初始化登录框位置（垂直居中、水平4/7）
function initWindow(){
var middle = 3;
var colorNum = 200;
@ -125,17 +115,13 @@
var screen = document.getElementsByClassName('screen')[0];
var title = document.getElementsByClassName('title')[0];
var bodys = document.getElementsByTagName('body')[0];
// 设置页面背景大小适应页面宽度
bodys.style.cssText = "background-size: " + clientWidth + "px auto;";
// 设置登录内容区域的外边距，使其垂直居中、水平处于页面特定位置
content.style.cssText = "margin:" + (clientHeight - content.clientHeight)/2 +"px " +
clientWidth*4/7 + "px " +
(clientHeight - content.clientHeight)/2 + "px;";
// 设置宣传元素区域的外边距，使其在登录内容区域内相对居中
screen.style.cssText = "margin:" + (content.clientHeight - screen.clientHeight)/2 +"px " +
(clientWidth*4/7 - screen.clientWidth)/2 + "px " +
(content.clientHeight - screen.clientHeight)/2 + "px;";
// 通过定时器改变标题颜色，实现颜色动态变化效果
setInterval(function(){
colorNum += middle;
if(colorNum>185){
@ -147,33 +133,29 @@
},30);
}
// 初始化登录界面，主要处理tab切换等相关操作
//初始化登录界面
function initLogin(){
var textNum = document.getElementById('TestNum');
var liArr = document.getElementsByTagName('li');
var divArr = document.getElementsByClassName("page")[0].getElementsByClassName("childpage");
// 点击验证码按钮时更新验证码显示的值
var divArr = document.getElementsByClassName("page")[0].getElementsByClassName("childpage");
textNum.onclick = function(){
textNum.value = TestNum();
}
// 遍历tab栏的li元素，添加点击事件处理函数
for(var i=0;i<liArr.length;i++){
liArr[i].index = i;
liArr[i].onclick = function(){
for(var i=0;i<liArr.length;i++){
liArr[i].index = i;
liArr[i].onclick = function(){
textNum.value = TestNum();
// 遍历页面中的子页面（登录和注册页面），先隐藏所有页面
for(var j=0;j<divArr.length;j++){
for(var j=0;j<divArr.length;j++){
liArr[j].style.cssText = "background-color:rgba(255, 255, 255, 0.2);";
divArr[j].style.display = "none";
}
// 设置当前点击的tab对应的页面显示，并改变其背景色
divArr[j].style.display = "none";
}
liArr[this.index].style.cssText = "background-color:rgba(255, 255, 255, 0);";
divArr[this.index].style.display = "block";
}
}
divArr[this.index].style.display = "block";
}
}
}
// 生成一个随机的验证码字符串（由数字和字母组成）
//更新验证码
function TestNum(){
var testNum = "";
var selectChar = new Array(0,1,2,3,4,5,6,7,8,9,'a','b','c','d','e','f','g','h','i','j','k','l',
@ -185,12 +167,11 @@
return testNum;
}
// 登录按钮点击时执行的函数，用于验证登录账号和密码信息
//登录账号和密码信息验证
function loginbtn(){
var user_name = $(".login_page").find("#UserName").val();
var user_pwd = $(".login_page").find("#PassWord").val();
var login_error = $(".login_error");
// 检查账号和密码是否为空，为空则显示相应提示
if((user_name == "") || (user_pwd == "")){
login_error.text("账号和密码不能为空");
}
@ -222,7 +203,7 @@
}
}
// 注册按钮点击时执行的函数，用于验证注册账号、密码、邮箱以及验证码等信息
//注册账号和密码逻信息验证
function registerbtn(){
var textNum = document.getElementById('TestNum');
var user_name = $(".register_page").find("#UserName").val();
@ -231,7 +212,6 @@
var register_error = $(".register_error");
var test = $("#Test").val();
var testbtn = $("#TestNum").val();
// 检查账号、密码、邮箱是否为空，为空则显示相应提示并更新验证码
if((user_name == "") || (user_pwd == "") || (user_email == "")){
register_error.text("账号和密码和邮箱不能为空");
textNum.value = TestNum();
@ -265,5 +245,6 @@
}
</script>
<!-- ------------------------------------------------------------------- -->
</body>
</html>

0
新建 文本文档 (2).txt
Unescape View File

1
新建 文本文档.txt
Unescape View File

@ -1 +0,0 @@
1
Write Preview
Loading…
Cancel
Save