Compare commits

..

No commits in common. 'main' and 'master' have entirely different histories.
main ... master

@ -1,2 +1,55 @@
# banban
# 仿猫眼电影购票系统
## 基于Spring+Spring MVC+Mybatis+Layui
### 功能:
* 前台:
* 登录、注册、注销
* 基本信息修改、修改头像、修改密码
* 按标签检索电影
* 根据电影选择场次
* 根据场次选择座位
* 购票
* 查看个人订单
* 申请退票
* 发布评论、修改评论、删除评论
* 后台:
+ 用户管理:增、删、改、查
+ 电影管理:添加电影、修改和下架前台在映的电影
+ 场次管理:
- 添加场次:选择影院、影院放映厅、电影、场次时间
- 场次下架
- 检索场次
- 查看上映、下架场次
+ 评论管理:查看评论、根据用户检索评论、修改、删除
+ 订单管理:
- 根据用户/订单编号检索订单
- 查看退票的订单
- 退票审核
+ 票房统计:
- 统计系统电影类型的票房数据
- 统计系统电影票房排行前10的电影及票房<br>
### 前台预览:
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/index.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/电影.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/详情.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/选择影院.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/选择场次.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/选择位置.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/pay.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/success.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/个人信息.png)
![qiantai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/订单.png)
### 后台预览:
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/user.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/movie.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/movieadd.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/updatemovie.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/eva.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/schedule1.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/schedule2.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/scheduleadd.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/order1.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/order2.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/order3.png)
![houtai](https://github.com/banbanzzz/Movie/blob/master/src/main/webapp/github/data.png)

File diff suppressed because it is too large Load Diff

@ -19,210 +19,164 @@ 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;
}
/**
*
*
* IDID
*
*
*
* @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;
}
/**
*
* IDID
*
*
* @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;
/**
*
*
* @return JSONObject
*/
@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()));
}
// 构建返回的JSON对象包含代码、消息、评论数量和数据
obj.put("code", 0); // 状态码0表示成功
obj.put("msg", ""); // 返回消息,这里为空
obj.put("count", list.size()); // 评论总数
obj.put("data", list); // 评论数据
return obj;
}
/**
*
*
* @param page
* @param limit
* @param keyword
* @return JSONObject
*/
@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()) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
// 构建返回的JSON对象包含代码、消息、评论总数和分页数据
JSONObject obj = new JSONObject();
obj.put("code", 0); // 状态码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;
}
}

@ -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;
}
}

@ -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;
}
}

@ -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;
}
}

@ -24,273 +24,189 @@ import com.entity.User;
import com.github.pagehelper.PageInfo;
import com.service.IUserService;
import com.util.UUIDUtil;
/**
*
*
* update: 20197917: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;
}
}

File diff suppressed because it is too large Load Diff

@ -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; // 电影海报地址
// 电影的状态信息,用整数表示,默认值为 11 代表电影处于在线状态可正常观看、展示等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;
}
}

@ -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;
}
}

@ -0,0 +1,489 @@
package com.entity;
/**
* 评论表实体对象
* @author Wxj
*/
import java.util.Date;
public class Comment {
private long comment_id;
private long user_id; //所属用户编号
private String comment_content; //评论内容
private long movie_id; //所属电影编号
private Date comment_time; //评论时间
private User comment_user; //所属用户
public long getComment_id() {
return comment_id;
}
public void setComment_id(long comment_id) {
this.comment_id = comment_id;
}
public long getUser_id() {
return user_id;
}
public void setUser_id(long user_id) {
this.user_id = user_id;
}
public String getComment_content() {
return comment_content;
}
public void setComment_content(String comment_content) {
this.comment_content = comment_content;
}
public long getMovie_id() {
return movie_id;
}
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
public Date getComment_time() {
return comment_time;
}
public void setComment_time(Date comment_time) {
this.comment_time = comment_time;
}
public User getComment_user() {
return comment_user;
}
public void setComment_user(User comment_user) {
this.comment_user = comment_user;
}
}
package com.entity;
import java.util.List;
/**
* 电影院表实体对象
* @author Wxj
*/
public class Cinema {
private long cinema_id;
private String cinema_name; //影院名称
private String cinema_address; //影院地址
private List<Hall> hallList; //所有的放映厅集合
public long getCinema_id() {
return cinema_id;
}
public void setCinema_id(long cinema_id) {
this.cinema_id = cinema_id;
}
public String getCinema_name() {
return cinema_name;
}
public void setCinema_name(String cinema_name) {
this.cinema_name = cinema_name;
}
public String getCinema_address() {
return cinema_address;
}
public void setCinema_address(String cinema_address) {
this.cinema_address = cinema_address;
}
public List<Hall> getHallList() {
return hallList;
}
public void setHallList(List<Hall> hallList) {
this.hallList = hallList;
}
}
package com.entity;
import java.util.List;
/**
* 放映厅表实体对象
* @author Wxj
*/
public class Hall {
private long hall_id;
private String hall_name; //放映厅名称
private int hall_capacity; //放映厅容量
private long cinema_id; //所属影院编号
private Cinema hall_cinema; //所属影院
private List<Schedule> ScheduleList; //所有的电影场次集合
public long getHall_id() {
return hall_id;
}
public void setHall_id(long hall_id) {
this.hall_id = hall_id;
}
public List<Schedule> getScheduleList() {
return ScheduleList;
}
public void setScheduleList(List<Schedule> scheduleList) {
ScheduleList = scheduleList;
}
public Cinema getHall_cinema() {
return hall_cinema;
}
public void setHall_cinema(Cinema hall_cinema) {
this.hall_cinema = hall_cinema;
}
public String getHall_name() {
return hall_name;
}
public void setHall_name(String hall_name) {
this.hall_name = hall_name;
}
public int getHall_capacity() {
return hall_capacity;
}
public void setHall_capacity(int hall_capacity) {
this.hall_capacity = hall_capacity;
}
public long getCinema_id() {
return cinema_id;
}
public void setCinema_id(long cinema_id) {
this.cinema_id = cinema_id;
}
}
package com.entity;
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; //电影详情
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;
}
}
package com.entity;
import java.util.Date;
import java.util.List;
/**
* 订单表实体对象
* @author Wxj
*
*/
public class Order {
private String order_id;
private long user_id; //所属用户编号
private long schedule_id; //所属场次编号,通过schedule_id-》场次信息-》放映厅信息+电影信息
private String order_position; //电影票座位信息
private int order_state; //订单状态 0退票中 -1无法退票 1已支付 2退票成功
private int order_price; //订单价格
private Date order_time; //订单支付时间
private User order_user; //所属用户对象
private Schedule order_schedule; //所属电影场次
public String getOrder_id() {
return order_id;
}
public void setOrder_id(String order_id) {
this.order_id = order_id;
}
public Date getOrder_time() {
return order_time;
}
public void setOrder_time(Date order_time) {
this.order_time = order_time;
}
public int getOrder_price() {
return order_price;
}
public void setOrder_price(int order_price) {
this.order_price = order_price;
}
public long getUser_id() {
return user_id;
}
public void setUser_id(long user_id) {
this.user_id = user_id;
}
public long getSchedule_id() {
return schedule_id;
}
public void setSchedule_id(long schedule_id) {
this.schedule_id = schedule_id;
}
public String getOrder_position() {
return order_position;
}
public void setOrder_position(String order_position) {
this.order_position = order_position;
}
public User getOrder_user() {
return order_user;
}
public int getOrder_state() {
return order_state;
}
public void setOrder_state(int order_state) {
this.order_state = order_state;
}
public void setOrder_user(User order_user) {
this.order_user = order_user;
}
public Schedule getOrder_schedule() {
return order_schedule;
}
public void setOrder_schedule(Schedule order_schedule) {
this.order_schedule = order_schedule;
}
}
package com.entity;
import java.util.Date;
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; //剩余座位数
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;
}
}
package com.entity;
/**
* 用户表实体对象
* @author Wxj
*/
public class User {
private long user_id;
private String user_name; //用户账号
private String user_pwd; //用户密码
private String user_email; //用户邮箱
private int user_role; //用户权限 0普通会员 1管理员
private String user_headImg; //用户头像地址
public long getUser_id() {
return user_id;
}
public void setUser_id(long user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getUser_pwd() {
return user_pwd;
}
public void setUser_pwd(String user_pwd) {
this.user_pwd = user_pwd;
}
public String getUser_email() {
return user_email;
}
public void setUser_email(String user_email) {
this.user_email = user_email;
}
public int getUser_role() {
return user_role;
}
public void setUser_role(int user_role) {
this.user_role = user_role;
}
public String getUser_headImg() {
return user_headImg;
}
public void setUser_headImg(String user_headImg) {
this.user_headImg = user_headImg;
}
}

@ -6,70 +6,13 @@ import org.springframework.stereotype.Repository;
import com.entity.Cinema;
/**
* CinemaMapper
* Mapper
* 使`@Repository`Spring便Spring
*/
@Repository
public interface CinemaMapper {
/**
* ID
* SQL使MyBatisXMLSQLID`Cinema`
* @param cinema_id ID
* @return `Cinema``null`
*/
Cinema findCinemaById(long cinema_id);
/**
*
* SQL`Cinema`
* 10
* @param cinema `Cinema`
* @return `Integer`
*/
Integer addCinema(Cinema cinema);
/**
* `Cinema`
* SQL`Cinema`
*
* @param cinema `Cinema`
* @return `Integer`
*/
Integer updateCinema(Cinema cinema);
/**
* ID
* SQLID10
* @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);
}

@ -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>

@ -8,58 +8,14 @@ import com.entity.Comment;
@Repository
public interface CommentMapper {
/**
* ID
*
* @param comment_id
* @return IDnull
*/
Comment findCommentById(long comment_id);
/**
*
*
* @param comment
* @return 10
*/
Integer addComemnt(Comment comment);
/**
*
*
* @param comment
* @return 10
*/
Integer updateComment(Comment comment);
/**
* ID
*
* @param comment_id
* @return 10
*/
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);
}

@ -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>

@ -7,71 +7,14 @@ import org.springframework.stereotype.Repository;
import com.entity.Hall;
/**
* HallMapperHall
* Mapper
* 使`@Repository`Spring便Spring
*/
@Repository
public interface HallMapper {
/**
* ID
* SQL使MyBatisXMLSQLID`Hall`
* @param hall_id ID
* @return `Hall``null`
*/
Hall findHallById(long hall_id);
/**
*
* 使`@Param`便SQLSQL
* `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`
* 10
* @param hall `Hall`
* @return `Integer`
*/
Integer addHall(Hall hall);
/**
* `Hall`
* SQL`Hall`
*
* @param hall `Hall`
* @return `Integer`
*/
Integer updateHall(Hall hall);
/**
* ID
* SQLID10
* @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();
}

@ -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>

@ -7,140 +7,23 @@ import org.springframework.stereotype.Repository;
import com.entity.Movie;
/**
* MovieMapperMovie
* Mapper
* 使`@Repository`Spring便Spring
*/
@Repository
public interface MovieMapper {
/**
* ID
* SQL使MyBatisXMLSQLID`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`
* 10
* @param movie `Movie`
* @return `Integer`
*/
Integer addMovie(Movie movie);
/**
* ID
* SQLID10
* @param movie_id ID
* @return `Integer`
*/
Integer deleteMovie(long movie_id);
/**
* `Movie`
* SQL`Movie`
*
* @param movie `Movie`
* @return `Integer`
*/
Integer updateMovie(Movie movie);
/**
* ID
* SQLID0
*
* @param movie_id ID
* @return `Integer`
*/
Integer deleteMovieCommentCount(long movie_id);
/**
* ID
* SQLID
*
* @param movie_id ID
* @return `Integer`
*/
Integer addMovieCommentCount(long movie_id);
/**
* ID
* `@Param`便SQLSQLID
*
* @param movie_boxOffice
* @param movie_id ID
* @return `Integer`
*/
Integer changeMovieBoxOffice(@Param("movie_boxOffice") float movie_boxOffice, @Param("movie_id") long movie_id);
/**
* 线
* SQL1线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();
}

@ -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>

@ -1,94 +1,21 @@
package com.mapper;
import java.util.List;
import java.util.List;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Repository;
import com.entity.Order;
import com.entity.Order;
/**
* OrderMapperOrder
* Mapper
* 使`@Repository`Spring便Spring
*/
@Repository
public interface OrderMapper {
/**
* ID
* SQL使MyBatisXMLSQLID`Order`便
* @param order_id
* @return `Order``null`
*/
Order findOrderById(String order_id);
/**
*
* SQL`Order`
* 10
* @param order `Order`
* @return `Integer`
*/
Integer addOrder(Order order);
/**
* 退
* SQLorder_id退退
* 10退
* @param order_id 退
* @return `Integer`
*/
Integer updateOrderStateToRefund(String order_id); //申请退票
/**
* 退
* SQLorder_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
* SQLID
* `Order``List<Order>`便
* @param schedule_id
* @return `Order``List`
*/
List<Order> findOrdersByScheduleId(long schedule_id);
/**
*
* SQL10退
* `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);
}

@ -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>

@ -7,118 +7,18 @@ import org.springframework.stereotype.Repository;
import com.entity.Schedule;
/**
* ScheduleMapperSchedule
* Mapper
* 使`@Repository`Spring便Spring
*/
@Repository
public interface ScheduleMapper {
/**
* ID
* SQL使MyBatisXMLSQLID`Schedule`便
* @param schedule_id
* @return `Schedule``null`
*/
Schedule findScheduleById(long schedule_id);
/**
*
* SQL`Schedule`
* 10
* @param schedule `Schedule`
* @return `Integer`
*/
Integer addSchedule(Schedule schedule);
/**
* `Schedule`
* SQL`Schedule`
*
* @param schedule `Schedule`
* @return `Integer`
*/
Integer updateSchedule(Schedule schedule);
/**
* ID
* SQLID10
* @param schedule_id
* @return `Integer`
*/
Integer deleteSchedule(long schedule_id);
/**
*
* SQLschedule_idSQL
* 退
* @param schedule_id
* @return `Integer`
*/
Integer addScheduleRemain(long schedule_id);
/**
*
* SQLIDschedule_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);
/**
*
* SQL10
* `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();
/**
* IDID
* `@Param`便SQLSQLIDID
* `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);
/**
* IDIDID
* `@Param`SQLIDIDID
* `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);
}

@ -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>

@ -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 10
*/
Integer addUser(User user);
/**
* ID
*
* @param user_id ID
* @return 10
*/
Integer deleteUser(long user_id);
/**
* ID
*
* @param user
* @return 10
*/
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);
}

@ -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>

@ -0,0 +1,150 @@
package com.mapper;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.entity.Cinema;
@Repository
public interface CinemaMapper {
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);
}
package com.mapper;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.entity.Comment;
@Repository
public interface CommentMapper {
//用户: 修改评论、增加评论
//管理员: 删除评论、 修改评论
//查询用户的评论
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);
}
package com.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import com.entity.Hall;
@Repository
public interface HallMapper {
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();
}
package com.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import com.entity.Movie;
@Repository
public interface MovieMapper {
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();
}
package com.mapper;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.entity.Order;
@Repository
public interface OrderMapper {
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);
}
package com.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import com.entity.Schedule;
@Repository
public interface ScheduleMapper {
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);
}
package com.mapper;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.entity.User;
@Repository
public interface UserMapper {
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);
}

@ -4,66 +4,12 @@ import java.util.List;
import com.entity.Cinema;
/**
* ICinemaServiceCinema
* Mapper
*/
public interface ICinemaService {
/**
* ID
* ID`Cinema`便
* @param cinema_id
* @return `Cinema``null`
*/
Cinema findCinemaById(long cinema_id);
/**
*
* `Cinema`10
* @param cinema `Cinema`
* @return `Integer`
*/
Integer addCinema(Cinema cinema);
/**
* `Cinema`
* `Cinema`
* @param cinema `Cinema`
* @return `Integer`
*/
Integer updateCinema(Cinema cinema);
/**
* ID
* ID10
* @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);
}

@ -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 10
*/
Integer addComemnt(Comment comment);
/**
* ID
*
* @param comment Comment
* @return 10
*/
Integer updateComment(Comment comment);
/**
* ID
*
* @param comment_id ID
* @return 10
*/
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);
}

@ -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 10
*/
Integer addHall(Hall hall);
/**
* ID
*
* @param hall Hall
* @return 10
*/
Integer updateHall(Hall hall);
/**
* ID
*
* @param hall_id ID
* @return 10
*/
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();
}

@ -4,134 +4,21 @@ import java.util.List;
import com.entity.Movie;
/**
* IMovieServiceMovie
*
*/
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`10
* @param movie `Movie`
* @return `Integer`
*/
Integer addMovie(Movie movie);
/**
* ID
* ID10
* @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);
/**
*
* 10
* `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();
}

@ -5,86 +5,14 @@ import java.util.List;
import com.entity.Order;
import com.github.pagehelper.PageInfo;
/**
* IOrderServiceOrder
* ID退退便
*/
public interface IOrderService {
/**
* ID
* ID`Order`便
* @param order_id
* @return `Order``null`
*/
Order findOrderById(String order_id);
/**
*
* `Order`IDID10
* @param order `Order`
* @return `Integer`
*/
Integer addOrder(Order order);
/**
* 退
* order_id退退退10退
* @param order_id 退
* @return `Integer`
*/
Integer updateOrderStateToRefund(String order_id); //申请退票
/**
* 退
* order_id退退退退
* @param order_id 退
* @return `Integer`
*/
Integer updateOrderStateToRefunded(String order_id); //同意退票
/**
*
* pagelimituser_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);
/**
*
* pagelimitorder_state10退`Order``PageInfo<Order>`便
* @param page 1
* @param limit
* @param order_state
* @return `PageInfo<Order>`
*/
PageInfo<Order> findOrdersByState(Integer page, Integer limit, int order_state);
/**
*
* pagelimitkeyword`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);
}

@ -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 10
*/
Integer addSchedule(Schedule schedule);
/**
* ID
*
* @param schedule Schedule
* @return 10
*/
Integer updateSchedule(Schedule schedule);
/**
* ID
*
* @param schedule_id ID
* @return 10
*/
Integer deleteSchedule(long schedule_id);
/**
*
*
* @param schedule_id ID
* @return 10
*/
Integer addScheduleRemain(long schedule_id);
/**
*
*
* @param schedule_id ID
* @return 10
*/
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);
}

@ -1,87 +1,19 @@
package com.service;
import java.util.List;
import com.entity.User;
import com.github.pagehelper.PageInfo;
/**
* IUserServiceUser
* ID便
*/
public interface IUserService {
/**
*
* user_nameuser_pwd`null`
* @param user_name
* @param user_pwd
* @return `User``null`
*/
User login(String user_name, String user_pwd);
/**
*
* `User`10
* @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`10
* @param user `User`
* @return `Integer`
*/
Integer addUser(User user);
/**
* ID
* ID10
* @param user_id
* @return `Integer`
*/
Integer deleteUser(long user_id);
/**
*
* `User``List<User>`便
* @return `User``List`
*/
List<User> findAllUserInfos();
/**
*
* pagelimitkeyword`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);
}

@ -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 10
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Override
public Integer addCinema(Cinema cinema) {
return this.cinemaMapper.addCinema(cinema);
}
/**
* ID
*
* @param cinema Cinema
* @return 10
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Override
public Integer updateCinema(Cinema cinema) {
return this.cinemaMapper.updateCinema(cinema);
}
/**
* ID
*
* @param cinema_id ID
* @return 10
*/
@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;
}
}

@ -14,139 +14,77 @@ import com.github.pagehelper.PageInfo;
import com.mapper.CommentMapper;
import com.service.ICommentService;
/**
* CommentServiceImpICommentServiceComment
* CommentMapperSpring
* `@Service`Spring便Spring使
*/
@Service
public class CommentServiceImp implements ICommentService {
public class CommentServiceImp implements ICommentService{
/**
* SpringCommentMapper
*/
@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`10
* @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`ID10
* @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);
}
}
}

@ -12,125 +12,64 @@ import com.mapper.CinemaMapper;
import com.mapper.HallMapper;
import com.service.IHallService;
/**
* HallServiceImpIHallServiceHall
* SpringHallMapperCinemaMapperSpring
* `@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;
}
/**
* SpringHallMapper
*/
@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);
}
/**
* SpringCinemaMapper
*/
@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`IDIDCinemaMapper`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`10
* @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`ID10
* @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`IDCinemaMapper`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`IDCinemaMapper`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;
}
}

@ -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 10
*/
@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 10
*/
@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 10
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Override
public Integer delCommentCount(long movie_id) {
return this.movieMapper.deleteMovieCommentCount(movie_id);
}
/**
*
*
* @param movie Movie
* @return 10
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Override
public Integer addMovie(Movie movie) {
return this.movieMapper.addMovie(movie);
}
/**
* ID
*
* @param movie_id ID
* @return 10
*/
@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 10
*/
@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();
}
}

@ -21,222 +21,150 @@ import com.mapper.ScheduleMapper;
import com.mapper.UserMapper;
import com.service.IOrderService;
/**
* OrderServiceImpIOrderServiceOrder
* SpringMapperOrderMapperUserMapperScheduleMapperHallMapperMovieMapperCinemaMapperSpring
* `@Service`Spring便Spring使
*/
@Service
public class OrderServiceImp implements IOrderService {
/**
* SpringOrderMapper
*/
@Autowired
private OrderMapper orderMapper;
/**
* SpringUserMapper
*/
@Autowired
private UserMapper userMapper;
/**
* SpringScheduleMapper
*/
@Autowired
private ScheduleMapper scheduleMapper;
/**
* SpringHallMapper
*/
@Autowired
private HallMapper hallMapper;
/**
* SpringMovieMapper
*/
@Autowired
private MovieMapper movieMapper;
/**
* SpringCinemaMapper
*/
@Autowired
private CinemaMapper cinemaMapper;
/**
* ID
* `Propagation.REQUIRED``readOnly=true`
* OrderMapper`findOrderById`IDUserMapper`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`10
* @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退10退
* @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;
}
}

@ -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 10
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Override
public Integer addSchedule(Schedule schedule) {
return this.scheduleMapper.addSchedule(schedule);
}
/**
* ID
*
* @param schedule Schedule
* @return 10
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Override
public Integer updateSchedule(Schedule schedule) {
return this.scheduleMapper.updateSchedule(schedule);
}
/**
* ID
*
* @param schedule_id ID
* @return 10
*/
@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 10
*/
@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 10
*/
@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;
}
}

@ -14,150 +14,80 @@ import com.github.pagehelper.PageInfo;
import com.mapper.UserMapper;
import com.service.IUserService;
/**
* UserServiceImpIUserServiceUser
* UserMapperSpring
* 使`@Service`Spring便Spring使
*/
@Service
public class UserServiceImp implements IUserService {
public class UserServiceImp implements IUserService{
/**
* SpringUserMapper
*/
@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`10
* @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`10
* @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`ID10
* @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);
}
}

@ -0,0 +1,813 @@
package com.service.imp;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Cinema;
import com.entity.Hall;
import com.entity.Schedule;
import com.mapper.CinemaMapper;
import com.mapper.HallMapper;
import com.mapper.ScheduleMapper;
import com.service.ICinemaService;
@Service
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;
}
@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,rollbackFor=Exception.class)
@Override
public Integer addCinema(Cinema cinema) {
return this.cinemaMapper.addCinema(cinema);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateCinema(Cinema cinema) {
return this.cinemaMapper.updateCinema(cinema);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteCinema(long cinema_id) {
return this.cinemaMapper.deleteCinema(cinema_id);
}
@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;
}
@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;
}
}
package com.service.imp;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Comment;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mapper.CommentMapper;
import com.service.ICommentService;
@Service
public class CommentServiceImp implements ICommentService{
@Autowired
private CommentMapper commentMapper;
@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);
}
@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);
}
@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;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<Comment> findCommentsByMovieId(long movie_id) {
return this.commentMapper.findCommentsByMoiveId(movie_id);
}
}
package com.service.imp;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Hall;
import com.mapper.CinemaMapper;
import com.mapper.HallMapper;
import com.service.IHallService;
@Service
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;
}
@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 addHall(Hall hall) {
return this.hallMapper.addHall(hall);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer updateHall(Hall hall) {
return this.hallMapper.updateHall(hall);
}
@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class)
@Override
public Integer deleteHall(long hall_id) {
return this.hallMapper.deleteHall(hall_id);
}
@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;
}
@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;
}
}
package com.service.imp;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Comment;
import com.entity.Movie;
import com.mapper.CommentMapper;
import com.mapper.MovieMapper;
import com.mapper.UserMapper;
import com.service.IMovieService;
@Service
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();
}
}
package com.service.imp;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Hall;
import com.entity.Order;
import com.entity.Schedule;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mapper.CinemaMapper;
import com.mapper.HallMapper;
import com.mapper.MovieMapper;
import com.mapper.OrderMapper;
import com.mapper.ScheduleMapper;
import com.mapper.UserMapper;
import com.service.IOrderService;
@Service
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;
}
}
package com.service.imp;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.Hall;
import com.entity.Order;
import com.entity.Schedule;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mapper.CinemaMapper;
import com.mapper.HallMapper;
import com.mapper.MovieMapper;
import com.mapper.OrderMapper;
import com.mapper.ScheduleMapper;
import com.service.IScheduleService;
@Service
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;
}
}
package com.service.imp;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.entity.User;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mapper.UserMapper;
import com.service.IUserService;
@Service
public class UserServiceImp implements IUserService{
@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);
}
@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;
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<User> findAllUserInfos() {
return this.usermapper.findAllUser();
}
@Transactional(propagation=Propagation.REQUIRED,readOnly=true)
@Override
public List<User> findUserLikeName(String name) {
return this.usermapper.findUserLikeName(name);
}
}

@ -0,0 +1,129 @@
package com.service;
import java.util.List;
import com.entity.Cinema;
public interface ICinemaService {
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);
}
package com.service;
import java.util.List;
import com.entity.Comment;
import com.github.pagehelper.PageInfo;
public interface ICommentService {
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);
}
package com.service;
import java.util.List;
import com.entity.Hall;
public interface IHallService {
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();
}
package com.service;
import java.util.List;
import com.entity.Movie;
public interface IMovieService {
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();
}
package com.service;
import java.util.List;
import com.entity.Order;
import com.github.pagehelper.PageInfo;
public interface IOrderService {
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);
}
package com.service;
import java.util.List;
import com.entity.Schedule;
import com.github.pagehelper.PageInfo;
public interface IScheduleService {
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);
}
package com.service;
import java.util.List;
import com.entity.User;
import com.github.pagehelper.PageInfo;
public interface IUserService {
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);
}

@ -0,0 +1,489 @@
package com.entity;
/**
* 评论表实体对象
* @author Wxj
*/
import java.util.Date;
public class Comment {
private long comment_id;
private long user_id; //所属用户编号
private String comment_content; //评论内容
private long movie_id; //所属电影编号
private Date comment_time; //评论时间
private User comment_user; //所属用户
public long getComment_id() {
return comment_id;
}
public void setComment_id(long comment_id) {
this.comment_id = comment_id;
}
public long getUser_id() {
return user_id;
}
public void setUser_id(long user_id) {
this.user_id = user_id;
}
public String getComment_content() {
return comment_content;
}
public void setComment_content(String comment_content) {
this.comment_content = comment_content;
}
public long getMovie_id() {
return movie_id;
}
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
public Date getComment_time() {
return comment_time;
}
public void setComment_time(Date comment_time) {
this.comment_time = comment_time;
}
public User getComment_user() {
return comment_user;
}
public void setComment_user(User comment_user) {
this.comment_user = comment_user;
}
}
package com.entity;
import java.util.List;
/**
* 电影院表实体对象
* @author Wxj
*/
public class Cinema {
private long cinema_id;
private String cinema_name; //影院名称
private String cinema_address; //影院地址
private List<Hall> hallList; //所有的放映厅集合
public long getCinema_id() {
return cinema_id;
}
public void setCinema_id(long cinema_id) {
this.cinema_id = cinema_id;
}
public String getCinema_name() {
return cinema_name;
}
public void setCinema_name(String cinema_name) {
this.cinema_name = cinema_name;
}
public String getCinema_address() {
return cinema_address;
}
public void setCinema_address(String cinema_address) {
this.cinema_address = cinema_address;
}
public List<Hall> getHallList() {
return hallList;
}
public void setHallList(List<Hall> hallList) {
this.hallList = hallList;
}
}
package com.entity;
import java.util.List;
/**
* 放映厅表实体对象
* @author Wxj
*/
public class Hall {
private long hall_id;
private String hall_name; //放映厅名称
private int hall_capacity; //放映厅容量
private long cinema_id; //所属影院编号
private Cinema hall_cinema; //所属影院
private List<Schedule> ScheduleList; //所有的电影场次集合
public long getHall_id() {
return hall_id;
}
public void setHall_id(long hall_id) {
this.hall_id = hall_id;
}
public List<Schedule> getScheduleList() {
return ScheduleList;
}
public void setScheduleList(List<Schedule> scheduleList) {
ScheduleList = scheduleList;
}
public Cinema getHall_cinema() {
return hall_cinema;
}
public void setHall_cinema(Cinema hall_cinema) {
this.hall_cinema = hall_cinema;
}
public String getHall_name() {
return hall_name;
}
public void setHall_name(String hall_name) {
this.hall_name = hall_name;
}
public int getHall_capacity() {
return hall_capacity;
}
public void setHall_capacity(int hall_capacity) {
this.hall_capacity = hall_capacity;
}
public long getCinema_id() {
return cinema_id;
}
public void setCinema_id(long cinema_id) {
this.cinema_id = cinema_id;
}
}
package com.entity;
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; //电影详情
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;
}
}
package com.entity;
import java.util.Date;
import java.util.List;
/**
* 订单表实体对象
* @author Wxj
*
*/
public class Order {
private String order_id;
private long user_id; //所属用户编号
private long schedule_id; //所属场次编号,通过schedule_id-》场次信息-》放映厅信息+电影信息
private String order_position; //电影票座位信息
private int order_state; //订单状态 0退票中 -1无法退票 1已支付 2退票成功
private int order_price; //订单价格
private Date order_time; //订单支付时间
private User order_user; //所属用户对象
private Schedule order_schedule; //所属电影场次
public String getOrder_id() {
return order_id;
}
public void setOrder_id(String order_id) {
this.order_id = order_id;
}
public Date getOrder_time() {
return order_time;
}
public void setOrder_time(Date order_time) {
this.order_time = order_time;
}
public int getOrder_price() {
return order_price;
}
public void setOrder_price(int order_price) {
this.order_price = order_price;
}
public long getUser_id() {
return user_id;
}
public void setUser_id(long user_id) {
this.user_id = user_id;
}
public long getSchedule_id() {
return schedule_id;
}
public void setSchedule_id(long schedule_id) {
this.schedule_id = schedule_id;
}
public String getOrder_position() {
return order_position;
}
public void setOrder_position(String order_position) {
this.order_position = order_position;
}
public User getOrder_user() {
return order_user;
}
public int getOrder_state() {
return order_state;
}
public void setOrder_state(int order_state) {
this.order_state = order_state;
}
public void setOrder_user(User order_user) {
this.order_user = order_user;
}
public Schedule getOrder_schedule() {
return order_schedule;
}
public void setOrder_schedule(Schedule order_schedule) {
this.order_schedule = order_schedule;
}
}
package com.entity;
import java.util.Date;
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; //剩余座位数
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;
}
}
package com.entity;
/**
* 用户表实体对象
* @author Wxj
*/
public class User {
private long user_id;
private String user_name; //用户账号
private String user_pwd; //用户密码
private String user_email; //用户邮箱
private int user_role; //用户权限 0普通会员 1管理员
private String user_headImg; //用户头像地址
public long getUser_id() {
return user_id;
}
public void setUser_id(long user_id) {
this.user_id = user_id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public String getUser_pwd() {
return user_pwd;
}
public void setUser_pwd(String user_pwd) {
this.user_pwd = user_pwd;
}
public String getUser_email() {
return user_email;
}
public void setUser_email(String user_email) {
this.user_email = user_email;
}
public int getUser_role() {
return user_role;
}
public void setUser_role(int user_role) {
this.user_role = user_role;
}
public String getUser_headImg() {
return user_headImg;
}
public void setUser_headImg(String user_headImg) {
this.user_headImg = user_headImg;
}
}

@ -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);
}
}

@ -0,0 +1,169 @@
package com.util;
/**
* 返回给浏览器的数据
* @param success 状态 true:成功 false:失败
* @param msg 提示信息
* @author Wxj
*/
public class ResponseModel {
private boolean success;
private String msg;
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
/**
* 默认成功
* @param msg
*/
public ResponseModel(String msg) {
this.setSuccess(true);
this.setMsg(msg);
}
public ResponseModel(boolean success,String msg) {
this.setSuccess(success);
this.setMsg(msg);
}
}
package com.util;
import java.io.Console;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Random;
import com.alibaba.fastjson.JSONObject;
public class test {
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);
}
}
package com.util;
import java.util.UUID;
/**
* 生产唯一标识符
* @author Wxj
*/
public class UUIDUtil {
public static String getUUID() {
String str = UUID.randomUUID().toString();
str = str.replace("-", "");
return str;
}
}

File diff suppressed because it is too large Load Diff

@ -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>
Loading…
Cancel
Save