Compare commits

..

1 Commits
main ... zwk

Author SHA1 Message Date
STRIV1 da9002367a zwk
1 year ago

@ -19,210 +19,132 @@ import com.service.IMovieService;
import com.service.IUserService;
/**
*
* JSON
*
* .
* @author Wxj
*/
@Controller
@RequestMapping("/comment") // 设置该Controller的基础路径为/comment意味着该控制器下的所有请求路径都以此为前缀
@RequestMapping("/comment")
public class CommentController {
// 自动装配ICommentService用于调用评论相关的业务逻辑方法如查询、添加、更新、删除评论等操作。
@Resource
private ICommentService commentService;
// 自动装配IUserService用于获取用户相关信息例如根据用户ID查找用户详细信息等操作辅助评论业务逻辑处理比如补充评论中的用户信息。
@Resource
private IUserService userService;
// 自动装配IMovieService用于处理电影相关业务比如更新电影的评论数量等操作与评论业务存在关联关系因为评论是针对电影发表的。
@Resource
private IMovieService movieService;
/**
*
* ID
* JSON
*
* @return JSON
*/
@RequestMapping("findAllComments")
@ResponseBody
public JSONObject findAllComments() {
JSONObject obj = new JSONObject();
// 调用评论服务的方法获取所有评论列表
List<Comment> list = commentService.findAllComments();
for (Comment comment : list) {
// 通过用户服务根据评论中记录的用户ID查找对应的用户对象并设置到评论对象中补充用户信息。
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
obj.put("code", 0); // 设置成功状态码,表示查询操作成功执行。
obj.put("msg", ""); // 无额外消息,此处可根据实际业务需求在有特殊情况时设置相应提示消息。
obj.put("count", list.size()); // 设置评论总数,即获取到的评论列表的大小。
obj.put("data", list); // 将包含完整用户信息的评论列表数据放入 "data" 字段返回给前端。
return obj;
}
/**
*
*
* JSON 便
*
* @param page 1使
* @param limit 10使
* @param keyword
* @return JSON
*/
@RequestMapping("findAllCommentsPage")
@ResponseBody
public JSONObject findAllCommentsPage(@RequestParam(value = "page", defaultValue = "1") Integer page,
@RequestParam(value = "limit", defaultValue = "10") Integer limit, String keyword) {
// 调用评论服务的分页查询方法,传入页码、每页显示数量以及关键词,获取符合条件的评论信息分页结果。
PageInfo<Comment> info = commentService.findAllCommentsBySplitPage(page, limit, keyword);
for (Comment comment : info.getList()) {
// 通过用户服务根据评论中记录的用户ID查找对应的用户对象并设置到评论对象中补充用户信息。
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0); // 设置成功状态码,表示分页查询操作成功执行。
obj.put("msg", ""); // 无额外消息,此处可根据实际业务需求在有特殊情况时设置相应提示消息。
obj.put("count", info.getTotal()); // 设置总记录数,即符合条件的评论总条数,从分页信息对象中获取。
obj.put("data", info.getList()); // 将包含完整用户信息的分页评论列表数据放入 "data" 字段返回给前端。
return obj;
}
/**
*
*
* 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;
//用户: 修改评论、增加评论
//管理员x 删除评论、 修改评论
//x查询用户的评论
@RequestMapping("findAllComments")
@ResponseBody
public JSONObject findAllComments() {
JSONObject obj = new JSONObject();
List<Comment> list = commentService.findAllComments();
for(Comment comment: list) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
obj.put("code", 0);
obj.put("msg","");
obj.put("count", list.size());
obj.put("data", list);
return obj;
}
//测试 info.getTotal
@RequestMapping("findAllCommentsPage")
@ResponseBody
public JSONObject findAllCommentsPage(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,String keyword) {
PageInfo<Comment> info = commentService.findAllCommentsBySplitPage(page, limit, keyword);
//System.out.println(info);
for(Comment comment : info.getList()) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
@RequestMapping("addCommentByUser")
@ResponseBody
public JSONObject addCommentByUser(@RequestParam("movie_id")long movie_id,@RequestParam("comment_content")String comment_content,HttpServletRequest request) {
User user = (User)request.getSession().getAttribute("user");
JSONObject obj = new JSONObject();
if(user == null) {
obj.put("code",200);
obj.put("msg", "您未登录,登录之后才可评论~");
}else {
Comment comment = new Comment();
comment.setComment_content(comment_content);
comment.setMovie_id(movie_id);
comment.setUser_id(user.getUser_id());
comment.setComment_time(new Date());
Integer rs = commentService.addComemnt(comment);
if(rs > 0) {
Integer rs2 = movieService.addCommentCount(comment.getMovie_id());
if(rs2 > 0) {
obj.put("code", 0);
obj.put("msg", "评论成功~");
}else {
obj.put("code",200);
obj.put("msg", "评论失败2~");
}
}else {
obj.put("code",200);
obj.put("msg", "评论失败~");
}
}
return obj;
}
@RequestMapping("updateComment")
@ResponseBody
public JSONObject updateComment(@RequestParam("comment_id")long comment_id,@RequestParam("comment_content")String comment_content) {
JSONObject obj = new JSONObject();
Comment comment = this.commentService.findCommentById(comment_id);
comment.setComment_time(new Date());
comment.setComment_content(comment_content);
Integer rs = commentService.updateComment(comment);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "修改成功~");
}else {
obj.put("code",200);
obj.put("msg", "修改失败~");
}
return obj;
}
@RequestMapping("deleteComemnt")
@ResponseBody
public JSONObject deleteComment(@RequestParam("comment_id")long comment_id) {
JSONObject obj = new JSONObject();
Integer rs2 = movieService.delCommentCount(commentService.findCommentById(comment_id).getMovie_id());
Integer rs = commentService.deleteComment(comment_id);
if(rs > 0) {
obj.put("code", 0);
obj.put("msg", "删除成功~");
}else {
obj.put("code", 200);
obj.put("msg", "删除失败~");
}
return obj;
}
@RequestMapping("findCommentsByUserName")
@ResponseBody
public JSONObject findCommentsByUserName(@RequestParam(value="page",defaultValue="1")Integer page,@RequestParam(value="limit",defaultValue="10")Integer limit,@RequestParam("user_name")String user_name) {
PageInfo<Comment> info = commentService.findCommentsByUserName(page, limit, user_name);
//System.out.println(info);
for(Comment comment : info.getList()) {
comment.setComment_user(userService.findUserById(comment.getUser_id()));
}
JSONObject obj = new JSONObject();
obj.put("code", 0);
obj.put("msg", "");
obj.put("count", info.getTotal());
obj.put("data", info.getList());
return obj;
}
}

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

@ -3,39 +3,59 @@ package com.entity;
import java.util.List;
/**
*
*
*
* GetterSetter访便
* @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;
}
}
// 电影院的唯一标识符,在数据库中通常作为主键,用于唯一区分不同的电影院记录,方便对特定电影院进行查找、管理以及关联其他相关业务操作(比如查询该影院下的放映厅、场次等信息)。
private long cinema_id;
// 影院名称,用于直观地标识每个电影院,方便用户识别和选择想去观影的影院,同时也便于在系统中进行影院相关的展示、统计等操作。
private String cinema_name; //影院名称
// 影院地址,记录电影院所在的具体地理位置信息,便于用户知晓如何前往观影,在地图导航、影院推荐等业务场景中会用到该属性。
private String cinema_address; //影院地址
// 所有的放映厅集合,用于存储该电影院内包含的所有放映厅信息,体现了电影院与放映厅之间的一对多关系,方便查询影院的放映厅布局、统计放映厅相关数据等业务操作。
private List<Hall> hallList; //所有的放映厅集合
// Getter方法用于获取电影院的唯一标识符cinema_id外部代码可以通过调用此方法获取电影院对象的该属性值遵循JavaBean规范常用于查找、对比等操作中确定具体电影院。
public long getCinema_id() {
return cinema_id;
}
// Setter方法用于设置电影院的唯一标识符cinema_id外部代码可以通过调用此方法来修改电影院对象的该属性值遵循JavaBean规范一般在创建或更新电影院记录时使用。
public void setCinema_id(long cinema_id) {
this.cinema_id = cinema_id;
}
// Getter方法用于获取影院名称cinema_name在展示电影院相关信息给用户如在电影购票页面展示可选影院名称等或者进行内部管理操作如根据名称查找电影院等可以获取该属性值进行相应操作。
public String getCinema_name() {
return cinema_name;
}
// Setter方法用于设置影院名称cinema_name例如在修改影院名称可能由于品牌升级、重新命名等原因或者添加新电影院时设置其对应的名称属性更新电影院对象的该属性值。
public void setCinema_name(String cinema_name) {
this.cinema_name = cinema_name;
}
// Getter方法用于获取影院地址cinema_address在展示电影院位置信息给用户如在地图导航中显示地址引导用户前往等或者进行基于地址的业务操作如查找附近影院等可以获取该属性值进行相应操作。
public String getCinema_address() {
return cinema_address;
}
// Setter方法用于设置影院地址cinema_address例如在电影院搬迁、地址变更等情况下通过此方法更新电影院对象的该属性值改变其地址记录。
public void setCinema_address(String cinema_address) {
this.cinema_address = cinema_address;
}
// Getter方法用于获取所有的放映厅集合hallList在需要了解该电影院的放映厅布局、查询具体放映厅信息、统计放映厅数量等业务场景中可以通过此方法获取对应的放映厅列表进行相应操作。
public List<Hall> getHallList() {
return hallList;
}
// Setter方法用于设置所有的放映厅集合hallList一般在创建电影院与放映厅的关联比如新建电影院后添加放映厅或者更新放映厅列表如新增、移除放映厅等情况通过此方法设置属性值维护电影院与放映厅之间的关系更新放映厅列表内容。
public void setHallList(List<Hall> hallList) {
this.hallList = hallList;
}
}

@ -1,53 +1,85 @@
package com.entity;
import java.util.Date;
/**
*
*
* 便
* GetterSetter访
* @author Wxj
*/
public class Comment {
import java.util.Date;
// 评论的唯一标识符,在数据库中通常作为主键,用于唯一区分不同的评论记录,方便对特定评论进行查找、管理以及在关联其他相关业务操作时作为关键标识。
private long comment_id;
// 所属用户编号,关联到用户表中的对应用户记录,表明该评论是由哪个用户发表的,用于确定评论的归属以及后续与用户相关的业务操作(如查询用户的所有评论等)。
private long user_id; //所属用户编号
// 评论内容,以字符串形式存储用户输入的具体评论文字信息,是评论的核心部分,会展示给其他用户查看,以体现对相应电影的评价和看法。
private String comment_content; //评论内容
// 所属电影编号,关联到电影表中的对应电影记录,用于明确该评论是针对哪部电影而发表的,方便在展示电影评论、统计电影相关评论数据等业务场景中使用。
private long movie_id; //所属电影编号
// 评论时间使用Date类型记录用户发表评论的具体时间点可用于按照时间顺序展示评论、统计不同时间段的评论数量等业务操作便于对评论的时效性等方面进行分析。
private Date comment_time; //评论时间
// 所属用户对象,通过关联关系可以获取发表该评论的用户的详细信息(如用户名、头像等),方便在业务逻辑中涉及用户相关信息展示或操作时使用,此处是对象形式的关联,与通过用户编号关联对应。
private User comment_user; //所属用户
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;
}
}
// Getter方法用于获取评论的唯一标识符comment_id外部代码可以通过调用此方法获取评论对象的该属性值遵循JavaBean规范常用于根据评论ID查找、对比等操作中确定具体评论。
public long getComment_id() {
return comment_id;
}
// Setter方法用于设置评论的唯一标识符comment_id外部代码可以通过调用此方法来修改评论对象的该属性值遵循JavaBean规范一般在创建或更新评论记录时使用。
public void setComment_id(long comment_id) {
this.comment_id = comment_id;
}
// Getter方法用于获取所属用户编号user_id可以用于进一步查询用户的详细信息或者在涉及用户关联的业务逻辑中作为关键参数使用比如查找该用户发表的其他评论等操作。
public long getUser_id() {
return user_id;
}
// Setter方法用于设置所属用户编号user_id例如在创建评论并关联到具体用户时通过此方法更新评论对象的该属性值建立评论与用户的关联。
public void setUser_id(long user_id) {
this.user_id = user_id;
}
// Getter方法用于获取评论内容comment_content在展示评论信息给其他用户、进行评论内容相关的文本分析等业务场景中可以通过此方法获取该属性值进行相应操作。
public String getComment_content() {
return comment_content;
}
// Setter方法用于设置评论内容comment_content例如在用户修改评论内容或者添加新评论时填写具体的评论文字通过此方法更新评论对象的该属性值。
public void setComment_content(String comment_content) {
this.comment_content = comment_content;
}
// Getter方法用于获取所属电影编号movie_id同样可用于关联电影相关信息或者作为查询、验证等业务操作的参数依据比如获取该电影的其他评论等信息。
public long getMovie_id() {
return movie_id;
}
// Setter方法用于设置所属电影编号movie_id在确定评论所针对的电影时通过此方法设置相应的电影编号属性确保评论与正确的电影对应起来。
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
// Getter方法用于获取评论时间comment_time在按照时间顺序展示评论、统计不同时间段的评论情况、判断评论的时效性等业务场景中可以获取该属性值进行相应操作依据具体的时间信息来做相关业务决策。
public Date getComment_time() {
return comment_time;
}
// Setter方法用于设置评论时间comment_time例如在一些特殊情况下如数据迁移、时间校正等需要更新评论的发表时间时通过此方法更新评论对象的该属性值改变其时间记录。
public void setComment_time(Date comment_time) {
this.comment_time = comment_time;
}
// Getter方法用于获取所属用户对象comment_user在需要获取发表评论的用户详细信息如用户名、头像等可以通过此方法获取对应的User对象进行相关操作比如展示评论者信息等情况。
public User getComment_user() {
return comment_user;
}
// Setter方法用于设置所属用户对象comment_user例如在关联评论与具体用户或者更新评论对应的用户时通过此方法设置属性值确保评论与正确的用户关联起来。
public void setComment_user(User comment_user) {
this.comment_user = comment_user;
}
}

@ -3,52 +3,83 @@ package com.entity;
import java.util.List;
/**
*
*
*
* GetterSetter访便
* @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;
}
}
// 放映厅的唯一标识符,在数据库中通常作为主键,用于唯一区分不同的放映厅记录,方便对特定放映厅进行查找、管理以及关联其他相关业务操作。
private long hall_id;
// 放映厅名称,用于直观地标识每个放映厅,方便用户在选择观影场次时知晓是在哪个具体的放映厅观看电影,也便于影院内部管理和区分不同的放映场所。
private String hall_name; //放映厅名称
// 放映厅容量,即该放映厅能够容纳的观众数量,在安排场次、统计可售票数等业务场景中会依据此属性来判断座位资源是否充足等情况。
private int hall_capacity; //放映厅容量
// 所属影院编号,关联到影院表中的对应记录,表明该放映厅隶属于哪个电影院,用于确定放映厅的归属以及后续与影院相关的业务操作(如查询影院下的所有放映厅等)。
private long cinema_id; //所属影院编号
// 所属影院对象,通过关联关系可以获取影院的详细信息(如影院名称、地址等),方便在业务逻辑中涉及影院相关信息展示或操作时使用,此处是对象形式的关联,与通过影院编号关联对应。
private Cinema hall_cinema; //所属影院
// 所有的电影场次集合,用于记录在该放映厅安排的所有电影场次信息,体现了放映厅与场次之间的一对多关系,方便在查询放映厅的排片情况、统计场次相关数据等业务场景中使用。
private List<Schedule> scheduleList; //所有的电影场次集合
// Getter方法用于获取放映厅的唯一标识符hall_id外部代码可以通过调用此方法获取放映厅对象的该属性值遵循JavaBean规范常用于查找、对比等操作中确定具体放映厅。
public long getHall_id() {
return hall_id;
}
// Setter方法用于设置放映厅的唯一标识符hall_id外部代码可以通过调用此方法来修改放映厅对象的该属性值遵循JavaBean规范一般在创建或更新放映厅记录时使用。
public void setHall_id(long hall_id) {
this.hall_id = hall_id;
}
// Getter方法用于获取所有的电影场次集合scheduleList在需要获取该放映厅的排片信息、统计场次相关数据如场次数量、不同时间段场次分布等等业务场景中可以通过此方法获取对应的场次列表进行相应操作。
public List<Schedule> getScheduleList() {
return scheduleList;
}
// Setter方法用于设置所有的电影场次集合scheduleList一般在创建放映厅与场次的关联比如为放映厅安排新的场次或者更新场次列表如场次时间调整、取消场次等情况通过此方法设置属性值维护放映厅与场次之间的关系更新场次列表内容。
public void setScheduleList(List<Schedule> scheduleList) {
this.scheduleList = scheduleList;
}
// Getter方法用于获取所属影院对象hall_cinema在需要获取影院详细信息如影院名称、地址等可以通过此方法获取对应的Cinema对象进行相关操作比如展示放映厅所属影院信息等情况。
public Cinema getHall_cinema() {
return hall_cinema;
}
// Setter方法用于设置所属影院对象hall_cinema例如在关联放映厅与具体影院或者更新放映厅对应的影院时通过此方法设置属性值确保放映厅与正确的影院关联起来。
public void setHall_cinema(Cinema hall_cinema) {
this.hall_cinema = hall_cinema;
}
// Getter方法用于获取放映厅名称hall_name在展示放映厅相关信息给用户如在购票页面展示可选放映厅名称等或者进行内部管理操作如根据名称查找放映厅等可以获取该属性值进行相应操作。
public String getHall_name() {
return hall_name;
}
// Setter方法用于设置放映厅名称hall_name例如在修改放映厅名称可能由于重新装修、命名调整等原因或者添加新放映厅时设置其对应的名称属性更新放映厅对象的该属性值。
public void setHall_name(String hall_name) {
this.hall_name = hall_name;
}
// Getter方法用于获取放映厅容量hall_capacity在安排场次、判断座位资源是否充足、统计可售票数等业务场景中可以获取该属性值进行相应操作依据容量信息来做相关业务决策。
public int getHall_capacity() {
return hall_capacity;
}
// Setter方法用于设置放映厅容量hall_capacity例如在放映厅进行改造、座位布局调整导致容量变化时通过此方法更新放映厅对象的该属性值改变其容量记录。
public void setHall_capacity(int hall_capacity) {
this.hall_capacity = hall_capacity;
}
// Getter方法用于获取所属影院编号cinema_id可以用于进一步查询影院的详细信息或者在涉及影院关联的业务逻辑中作为关键参数使用比如查找该影院下的其他放映厅等操作。
public long getCinema_id() {
return cinema_id;
}
// Setter方法用于设置所属影院编号cinema_id例如在创建放映厅并关联到具体影院时通过此方法更新放映厅对象的该属性值建立放映厅与影院的关联。
public void setCinema_id(long cinema_id) {
this.cinema_id = cinema_id;
}
}

@ -1,172 +1,205 @@
package com.entity;
import java.sql.Date; // 导入 java.sql.Date 类,用于表示日期,格式通常为 yyyy-mm-dd这里用于存储电影的相关日期信息
import java.sql.Date; // 导入用于表示日期的数据类型格式为yyyy-MM-dd用于存储电影的上映时间等日期相关信息。
import java.util.List;
/**
*
*
*
*
* GetterSetter访便
* @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 的方法,供外部类访问该私有属性
// 演职人员信息,通常包含主演、配角等参演人员的相关介绍,以字符串形式存储,方便在电影详情页等地方展示给用户了解电影的演员阵容。
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; //电影参评人数
// 上映时间,使用 java.sql.Date 类型存储电影正式在影院上映的日期格式为yyyy-MM-dd用于排片、上映计划展示以及判断电影是否处于上映周期等业务场景。
private Date movie_releaseDate; //上映时间
// 制片地区,用于说明电影是由哪个地区或国家制作的,在电影分类、地域特色展示等业务场景中有应用,例如展示不同地区的热门电影等。
private String movie_country; //制片地区
// 电影海报地址,存储电影海报图片在服务器上的相对或绝对路径,方便前端页面根据此地址获取对应的海报图片进行展示,增强电影的视觉呈现效果。
private String movie_picture; //电影海报地址
// 电影状态默认值为1表示电影当前的在线状态1在线意味着可正常展示、排片、购票观看等0下架表示电影已从正常业务流程中移除不再对外展示和提供服务用于控制电影在系统中的展示和可用性。
private int movie_state; //电影状态 默认1 1在线 0下架
// 所有的评论信息,以列表形式存储该电影对应的所有用户评论对象,方便在展示电影详情页的评论区、统计评论相关数据等业务场景中使用,体现了电影与评论之间的一对多关系。
private List<Comment> commentList; //所有的评论信息
// Getter方法用于获取电影的唯一标识符movie_id外部代码可以通过调用此方法获取电影对象的该属性值遵循JavaBean规范常用于根据电影ID查找、对比等操作中确定具体电影。
public long getMovie_id() {
return movie_id;
}
// 设置电影的唯一标识符 movie_id 的方法,外部类可以通过该方法给 movie_id 属性赋值
// Setter方法用于设置电影的唯一标识符movie_id外部代码可以通过调用此方法来修改电影对象的该属性值遵循JavaBean规范一般在创建或更新电影记录时使用。
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
// 获取电影的中文名称 movie_cn_name 的方法,用于外部获取该属性值展示或者使用
// Getter方法用于获取电影的中文名称movie_cn_name在展示电影相关信息给用户如电影列表展示、详情页展示中文名称等时可以获取该属性值进行相应操作。
public String getMovie_cn_name() {
return movie_cn_name;
}
// 获取电影的状态 movie_state 的方法,外部可通过此方法得知电影当前处于在线还是下架等状态
// Getter方法用于获取电影状态movie_state方便在业务逻辑中根据电影状态进行不同的操作处理例如判断电影是否可购票观看、是否展示在列表中等情况。
public int getMovie_state() {
return movie_state;
}
// 设置电影的状态 movie_state 的方法,外部可通过此方法改变电影的状态(比如管理员操作下架电影等情况)
// Setter方法用于设置电影状态movie_state例如在管理员操作电影上下架时通过此方法更新电影对象的该属性值改变电影的在线或下架状态。
public void setMovie_state(int movie_state) {
this.movie_state = movie_state;
}
// 设置电影的中文名称 movie_cn_name 的方法,外部类可调用此方法来更新电影的中文名称
// Setter方法用于设置电影的中文名称movie_cn_name例如在修改电影中文名称或者添加新电影时设置其对应的中文名称属性更新电影对象的该属性值。
public void setMovie_cn_name(String movie_cn_name) {
this.movie_cn_name = movie_cn_name;
}
// 获取电影的外文名称 movie_fg_name 的方法,供外部类在需要时获取该属性值
// Getter方法用于获取电影的外文名称movie_fg_name在需要展示外文名称的业务场景如国际影片相关展示或多语言环境下的信息呈现等中可以获取该属性值进行相应操作。
public String getMovie_fg_name() {
return movie_fg_name;
}
// 设置电影的外文名称 movie_fg_name 的方法,外部可通过调用此方法来修改电影的外文名称
// Setter方法用于设置电影的外文名称movie_fg_name例如在更新电影的外文名称信息时通过此方法更新电影对象的该属性值改变其外文名称记录。
public void setMovie_fg_name(String movie_fg_name) {
this.movie_fg_name = movie_fg_name;
}
// 获取电影的演职人员信息 movie_actor 的方法,用于外部展示或者处理相关人员信息
// Getter方法用于获取演职人员信息movie_actor在电影详情页等地方展示电影的演员阵容时可以通过此方法获取该属性值进行展示操作。
public String getMovie_actor() {
return movie_actor;
}
// 设置电影的演职人员信息 movie_actor 的方法,外部可调用此方法更新演职人员相关内容(比如新增演员等情况)
// Setter方法用于设置演职人员信息movie_actor例如在更新电影的演职人员信息或者添加新电影时填写演职人员相关内容通过此方法更新电影对象的该属性值。
public void setMovie_actor(String movie_actor) {
this.movie_actor = movie_actor;
}
// 获取电影的导演信息 movie_director 的方法,方便外部获取并展示导演相关信息
// Getter方法用于获取导演信息movie_director在展示电影创作的关键人物导演相关信息时可以通过此方法获取该属性值进行展示操作比如在电影详情页呈现导演名字。
public String getMovie_director() {
return movie_director;
}
// 设置电影的导演信息 movie_director 的方法,外部可通过此方法改变电影的导演信息(比如有误录入需要修改等情况)
// Setter方法用于设置导演信息movie_director例如在修改电影的导演信息或者添加新电影时确定导演相关内容通过此方法更新电影对象的该属性值。
public void setMovie_director(String movie_director) {
this.movie_director = movie_director;
}
// 获取电影的详细介绍内容 movie_detail 的方法,用于在前端页面等地方展示电影的详细情况给用户查看
// Getter方法用于获取电影详情描述movie_detail在需要向用户展示电影详细剧情、主题、特色等内容时可以通过此方法获取该属性值进行相应展示操作常用于电影详情页面的展示。
public String getMovie_detail() {
return movie_detail;
}
// 设置电影的详细介绍内容 movie_detail 的方法,外部可通过调用此方法更新电影的详细介绍信息(比如补充更详细的剧情等情况)
// Setter方法用于设置电影详情描述movie_detail例如在更新电影的详细介绍内容或者添加新电影时填写电影详情相关文字通过此方法更新电影对象的该属性值。
public void setMovie_detail(String movie_detail) {
this.movie_detail = movie_detail;
}
// 获取电影的时长信息 movie_duration 的方法,外部可通过此方法获取并展示给用户影片播放时长情况
// Getter方法用于获取电影时长movie_duration在让用户知晓电影播放时长情况以及在排片、观影安排等业务场景中考虑电影时长因素时可以通过此方法获取该属性值进行相应操作。
public String getMovie_duration() {
return movie_duration;
}
// 设置电影的时长信息 movie_duration 的方法,外部可调用此方法更新电影时长信息(比如纠正错误时长等情况)
// Setter方法用于设置电影时长movie_duration例如在修改电影时长信息可能存在不同版本时长不同等情况通过此方法更新电影对象的该属性值改变其时长记录。
public void setMovie_duration(String movie_duration) {
this.movie_duration = movie_duration;
}
// 获取电影的类型信息 movie_type 的方法,方便外部按类型进行分类、筛选、展示电影等操作
// Getter方法用于获取电影类型movie_type方便用户按照类型筛选电影也用于在电影分类统计、推荐等业务逻辑中获取该属性值进行相应操作比如查找某一类型的所有电影。
public String getMovie_type() {
return movie_type;
}
// 设置电影的类型信息 movie_type 的方法,外部可通过此方法修改电影的类型分类(比如重新归类等情况)
// Setter方法用于设置电影类型movie_type例如在更新电影的类型分类可能存在重新归类等情况或者添加新电影时确定电影类型相关内容通过此方法更新电影对象的该属性值。
public void setMovie_type(String movie_type) {
this.movie_type = movie_type;
}
// 获取电影的评分信息 movie_score 的方法,外部可通过此方法获取并展示电影的评分情况给用户参考
// Getter方法用于获取电影评分movie_score在展示电影质量评价情况、电影排序、推荐等业务场景中可以获取该属性值进行相应操作作为用户参考指标之一。
public float getMovie_score() {
return movie_score;
}
// 设置电影的评分信息 movie_score 的方法,一般来说评分是根据一定算法计算得出后通过此方法更新,而不是随意设置(实际应用中可能会有限制逻辑等)
// Setter方法用于设置电影评分movie_score例如在根据新的用户评价等情况重新计算并更新电影评分时通过此方法更新电影对象的该属性值改变其评分记录。
public void setMovie_score(float movie_score) {
this.movie_score = movie_score;
}
// 获取电影的票房数据 movie_boxOffice 的方法,用于外部统计、展示电影的商业票房表现情况
// Getter方法用于获取票房movie_boxOffice在统计、分析电影的商业表现如在电影相关统计报表、热门电影排序等业务中可以获取该属性值进行相应操作体现电影的营收情况。
public float getMovie_boxOffice() {
return movie_boxOffice;
}
// 设置电影的票房数据 movie_boxOffice 的方法,通常是在票房数据更新时(比如新的票房统计结果出来后)调用此方法进行设置
// Setter方法用于设置票房movie_boxOffice例如在有新的票房数据更新如实时票房数据同步等情况通过此方法更新电影对象的该属性值改变其票房记录。
public void setMovie_boxOffice(float movie_boxOffice) {
this.movie_boxOffice = movie_boxOffice;
}
// 获取电影的参评人数 movie_commentCount 的方法,外部可通过此方法获取参与评价的用户数量情况,用于参考评分可信度等
// Getter方法用于获取电影参评人数movie_commentCount在统计电影热度、评价活跃度等方面可作为参考数据结合评分等信息能更全面地反映电影受关注程度通过此方法获取该属性值进行相应操作。
public long getMovie_commentCount() {
return movie_commentCount;
}
// 设置电影的参评人数 movie_commentCount 的方法,在参评人数有变化(比如新用户参与评价等情况)时可调用此方法更新
// Setter方法用于设置电影参评人数movie_commentCount例如在有新的用户参与评价后更新参评人数统计时通过此方法更新电影对象的该属性值改变其参评人数记录。
public void setMovie_commentCount(long movie_commentCount) {
this.movie_commentCount = movie_commentCount;
}
// 获取电影的上映时间 movie_releaseDate 的方法,方便外部按上映时间查询、筛选电影等操作
// Getter方法用于获取上映时间movie_releaseDate在排片、上映计划展示以及判断电影是否处于上映周期等业务场景中可以获取该属性值进行相应操作按照指定的日期格式yyyy-MM-dd使用该时间信息。
public Date getReleaseDate() {
return movie_releaseDate;
}
// 设置电影的上映时间 movie_releaseDate 的方法,一般在录入电影信息或者修改上映时间等情况时调用此方法(不过实际应用中上映时间通常是确定后较少修改的)
// Setter方法用于设置上映时间movie_releaseDate例如在调整电影的上映计划修改上映日期可能存在延期、提前上映等情况通过此方法更新电影对象的该属性值改变其上映时间记录。
public void setReleaseDate(Date releaseDate) {
this.movie_releaseDate = releaseDate;
}
// 获取电影的制片地区信息 movie_country 的方法,外部可通过此方法获取并按地区分类、展示电影等
// Getter方法用于获取制片地区movie_country在电影分类、地域特色展示等业务场景中有应用例如展示不同地区的热门电影等通过此方法获取该属性值进行相应操作。
public String getMovie_country() {
return movie_country;
}
// 设置电影的制片地区信息 movie_country 的方法,在发现地区信息录入错误等情况时可调用此方法进行修改
// Setter方法用于设置制片地区movie_country例如在更新电影的制片地区信息可能存在信息纠错、重新标注等情况通过此方法更新电影对象的该属性值改变其制片地区记录。
public void setMovie_country(String movie_country) {
this.movie_country = movie_country;
}
// 获取电影海报地址信息 movie_picture 的方法,用于前端页面等获取海报图片资源展示电影海报
// Getter方法用于获取电影海报地址movie_picture前端页面根据此地址获取对应的海报图片进行展示增强电影的视觉呈现效果通过此方法获取该属性值进行相应操作获取海报图片资源路径。
public String getMovie_picture() {
return movie_picture;
}
// 设置电影海报地址信息 movie_picture 的方法,比如海报更换后可通过此方法更新地址信息
// Setter方法用于设置电影海报地址movie_picture例如在更新电影的海报图片后通过此方法将新的海报图片地址保存到电影对象中以便后续相关操作使用改变其海报地址记录。
public void setMovie_picture(String movie_picture) {
this.movie_picture = movie_picture;
}
// 获取该电影所有评论信息的列表 commentList 的方法,外部可通过此方法获取并展示、处理用户的评论内容
// Getter方法用于获取所有的评论信息commentList在展示电影详情页的评论区、统计评论相关数据等业务场景中可以获取该属性值评论列表进行相应操作体现了电影与评论之间的关联关系及数据获取。
public List<Comment> getCommentList() {
return commentList;
}
// 设置该电影所有评论信息的列表 commentList 的方法,一般在添加新评论、删除评论等操作后调用此方法更新评论列表(实际应用中可能会有更复杂的逻辑配合)
// Setter方法用于设置所有的评论信息commentList一般在创建电影与评论的关联或者更新评论列表比如新评论添加、旧评论删除等情况通过此方法设置属性值维护电影与评论之间的关系更新评论列表内容。
public void setCommentList(List<Comment> commentList) {
this.commentList = commentList;
}

@ -4,75 +4,119 @@ import java.util.Date;
import java.util.List;
/**
*
*
*
* GetterSetter访便
* @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;
}
}
// 订单的唯一标识符,通常具有唯一性,用于在系统中唯一区分不同的订单记录,可能包含了一定的业务规则生成的编号,方便订单的查找、管理等操作。
private String order_id;
// 所属用户编号,关联到用户表中的对应用户记录,表明该订单是由哪个用户创建的,用于确定订单的归属以及后续与用户相关的业务操作(如查询用户的所有订单等)。
private long user_id; //所属用户编号
// 所属场次编号,通过此编号可以关联到场次表中的对应场次记录,进而获取该场次的详细信息(如放映厅信息、电影信息等),方便在订单相关业务中涉及场次详情展示或操作时使用。
private long schedule_id; //所属场次编号,通过schedule_id-》场次信息-》放映厅信息+电影信息
// 电影票座位信息用于记录用户购买的具体座位位置例如“3排5座”等格式方便在观影、座位管理等业务场景中使用该信息。
private String order_position; //电影票座位信息
// 订单状态用于标识该订单当前所处的状态不同状态值代表不同含义如0表示退票中意味着用户正在申请退票-1表示无法退票可能是超过了退票时间等原因1表示已支付说明订单已完成支付正常等待观影2表示退票成功代表退票操作已完成订单已处理为退票状态可用于订单状态的判断及相应业务逻辑处理。
private int order_state; //订单状态 0退票中 -1无法退票 1已支付 2退票成功
// 订单价格,即用户购买该电影票实际支付的金额,用于记录订单的金额信息,在统计用户消费、场次收入等业务场景中会用到该数据。
private int order_price; //订单价格
// 订单支付时间,用于记录用户完成支付操作的具体时间,方便在查询订单历史、统计支付时间相关数据等业务场景中使用该时间信息进行分析或展示。
private Date order_time; //订单支付时间
// 所属用户对象,通过关联关系可以获取用户的详细信息(如用户名、联系方式等),方便在业务逻辑中涉及用户相关信息展示或操作时使用,此处是对象形式的关联,与通过用户编号关联对应。
private User order_user; //所属用户对象
// 所属电影场次,通过关联关系可以获取场次的详细信息(如放映时间、剩余座位数等),方便在业务逻辑中涉及场次相关信息展示或操作时使用,此处是对象形式的关联,与通过场次编号关联对应。
private Schedule order_schedule; //所属电影场次
// Getter方法用于获取订单的唯一标识符order_id外部代码可以通过调用此方法获取订单对象的该属性值遵循JavaBean规范常用于查找、对比等操作中确定具体订单。
public String getOrder_id() {
return order_id;
}
// Setter方法用于设置订单的唯一标识符order_id外部代码可以通过调用此方法来修改订单对象的该属性值遵循JavaBean规范一般在创建或更新订单记录时使用。
public void setOrder_id(String order_id) {
this.order_id = order_id;
}
// Getter方法用于获取订单支付时间order_time在展示订单详情、查询支付时间范围的订单等业务场景中可以获取该时间信息进行相应操作。
public Date getOrder_time() {
return order_time;
}
// Setter方法用于设置订单支付时间order_time例如在完成支付操作或者更新订单支付时间相关信息时通过此方法更新订单对象的该属性值改变订单的支付时间记录。
public void setOrder_time(Date order_time) {
this.order_time = order_time;
}
// Getter方法用于获取订单价格order_price可用于展示订单金额信息给用户或者在涉及价格统计、收入计算等业务操作中获取该订单的价格数据。
public int getOrder_price() {
return order_price;
}
// Setter方法用于设置订单价格order_price例如在修改订单价格可能存在特殊情况如补差价等通过此方法更新订单对象的该属性值调整订单的价格信息。
public void setOrder_price(int order_price) {
this.order_price = order_price;
}
// Getter方法用于获取所属用户编号user_id可以用于进一步查询用户的详细信息或者在涉及用户关联的业务逻辑中作为关键参数使用比如查找该用户的其他订单等操作。
public long getUser_id() {
return user_id;
}
// Setter方法用于设置所属用户编号user_id例如在创建订单并关联到具体用户时通过此方法更新订单对象的该属性值建立订单与用户的关联。
public void setUser_id(long user_id) {
this.user_id = user_id;
}
// Getter方法用于获取所属场次编号schedule_id同样可用于关联场次相关信息或者作为查询、验证等业务操作的参数依据比如获取场次的放映时间等信息。
public long getSchedule_id() {
return schedule_id;
}
// Setter方法用于设置所属场次编号schedule_id在确定订单所属的场次时通过此方法设置相应的场次编号属性确保订单与正确的场次对应起来。
public void setSchedule_id(long schedule_id) {
this.schedule_id = schedule_id;
}
// Getter方法用于获取电影票座位信息order_position在展示座位位置、核对座位等业务场景中可以获取该信息进行相应操作。
public String getOrder_position() {
return order_position;
}
// Setter方法用于设置电影票座位信息order_position例如在用户选择座位并创建订单时通过此方法更新订单对象的该属性值记录购买的座位信息。
public void setOrder_position(String order_position) {
this.order_position = order_position;
}
// Getter方法用于获取所属用户对象order_user在需要获取用户详细信息如用户名、联系方式等可以通过此方法获取对应的User对象进行相关操作比如展示订单所属用户信息等情况。
public User getOrder_user() {
return order_user;
}
// Getter方法用于获取订单状态order_state方便在业务逻辑中根据订单状态进行不同的操作处理例如判断订单是否可退票等情况。
public int getOrder_state() {
return order_state;
}
// Setter方法用于设置订单状态order_state例如在进行退票操作、支付操作等导致订单状态改变时通过此方法更新订单对象的该属性值更新订单的状态信息。
public void setOrder_state(int order_state) {
this.order_state = order_state;
}
// Setter方法用于设置所属用户对象order_user例如在关联订单与具体用户或者更新订单对应的用户时通过此方法设置属性值确保订单与正确的用户关联起来。
public void setOrder_user(User order_user) {
this.order_user = order_user;
}
// Getter方法用于获取所属电影场次order_schedule在需要获取场次详细信息如放映时间、剩余座位数等可以通过此方法获取对应的Schedule对象进行相关操作比如展示订单对应场次的详细情况等。
public Schedule getOrder_schedule() {
return order_schedule;
}
// Setter方法用于设置所属电影场次order_schedule例如在关联订单与具体场次或者更新订单对应的场次时通过此方法设置属性值确保订单与正确的场次关联起来。
public void setOrder_schedule(Schedule order_schedule) {
this.order_schedule = order_schedule;
}
}

@ -6,112 +6,133 @@ import java.util.List;
import org.springframework.format.annotation.DateTimeFormat;
/**
*
*
*
*
* GetterSetter访便
* @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;
// 获取场次的唯一标识符
// 所属放映厅的唯一标识符,关联到放映厅表中的对应记录,表明该场次是在哪个放映厅进行放映的
private long hall_id; //所属放映厅
// 放映的电影的编号,关联到电影表中的对应电影记录,用于确定该场次播放的是哪部电影
private long movie_id; //放映的电影编号
// 电影放映时间,用于记录该场次具体的开始放映时间,虽然此处注释掉了日期格式化注解,但理论上可按照指定格式(如"yyyy-MM-dd")进行时间格式的规范处理,方便时间的展示和比较等操作
//@DateTimeFormat(pattern="yyyy-MM-dd")
private String schedule_startTime; //电影放映时间
// 售价,即该场次电影票的价格,用于向用户展示票价信息以及在购票、结算等业务场景中使用
private int schedule_price; //售价
// 剩余座位数,用于实时记录该场次还有多少座位可供售卖,在购票、退票等操作时会相应地更新这个数值,反映座位的剩余情况
private int schedule_remain; //剩余座位数
// 场次状态,用于标识该场次当前的状态1表示上映中意味着该场次正常对外售票并即将放映0表示下架即该场次不再对外售票且不会放映了可用于场次筛选等业务逻辑判断
private int schedule_state; //场次状态 1上映中 0下架
// 所属放映厅对象,通过关联关系可以获取放映厅的详细信息(如放映厅名称、座位布局等),方便在业务逻辑中涉及放映厅相关信息展示或操作时使用,此处是对象形式的关联
private Hall schedule_hall; //所属放映厅对象
// 放映的电影对象,通过关联关系可以获取电影的详细信息(如电影名称、评分、类型等),方便在业务逻辑中涉及电影相关信息展示或操作时使用,此处是对象形式的关联
private Movie schedule_movie; //放映的电影
// 所有的订单集合,用于记录购买该场次电影票的所有订单信息,方便在统计场次收入、查询已购票用户等业务场景中使用,体现了场次与订单之间的一对多关系
private List<Order> orderList; //所有的订单集合
// Getter方法用于获取场次的唯一标识符schedule_id外部代码可以通过调用此方法获取场次对象的该属性值遵循JavaBean规范常用于查找、对比等操作中确定具体场次。
public long getSchedule_id() {
return schedule_id;
}
// 设置场次的唯一标识符
// Setter方法用于设置场次的唯一标识符schedule_id外部代码可以通过调用此方法来修改场次对象的该属性值遵循JavaBean规范一般在创建或更新场次记录时使用。
public void setSchedule_id(long schedule_id) {
this.schedule_id = schedule_id;
}
// 获取场次状态
// Getter方法用于获取场次状态schedule_state方便在业务逻辑中根据场次状态进行不同的操作处理例如判断场次是否可购票等情况。
public int getSchedule_state() {
return schedule_state;
}
// 设置场次状态
// Setter方法用于设置场次状态schedule_state例如在管理员操作场次上下架时通过此方法更新场次对象的状态属性值。
public void setSchedule_state(int schedule_state) {
this.schedule_state = schedule_state;
}
// 获取放映的电影对象
// Getter方法用于获取放映的电影对象schedule_movie在需要展示电影详细信息或者基于电影进行相关业务操作如统计票房等可以通过此方法获取对应的电影对象。
public Movie getSchedule_movie() {
return schedule_movie;
}
// 设置放映的电影对象
// Setter方法用于设置放映的电影对象schedule_movie一般在关联电影与场次或者更新场次所对应的电影时通过此方法设置属性值确保场次与正确的电影相关联。
public void setSchedule_movie(Movie schedule_movie) {
this.schedule_movie = schedule_movie;
}
// 获取所属放映厅的编号
// Getter方法用于获取所属放映厅的唯一标识符hall_id可以用于进一步查询放映厅的详细信息或者在涉及放映厅关联的业务逻辑中作为关键参数使用。
public long getHall_id() {
return hall_id;
}
// 设置所属放映厅的编号
// Setter方法用于设置所属放映厅的唯一标识符hall_id例如在安排场次到具体放映厅时通过此方法更新场次对象的该属性值建立场次与放映厅的关联。
public void setHall_id(long hall_id) {
this.hall_id = hall_id;
}
// 获取放映的电影编号
// Getter方法用于获取放映的电影编号movie_id同样可用于关联电影相关信息或者作为查询、验证等业务操作的参数依据。
public long getMovie_id() {
return movie_id;
}
// 设置放映的电影编号
// Setter方法用于设置放映的电影编号movie_id在确定场次播放的电影时通过此方法设置相应的电影编号属性确保场次与正确的电影对应起来。
public void setMovie_id(long movie_id) {
this.movie_id = movie_id;
}
// 获取电影放映时间
// Getter方法用于获取电影放映时间schedule_startTime在展示场次时间表、判断场次是否冲突等业务场景中可以获取该时间信息进行相应操作。
public String getSchedule_startTime() {
return schedule_startTime;
}
// 设置电影放映时间
// Setter方法用于设置电影放映时间schedule_startTime例如在调整场次时间安排时通过此方法更新场次对象的该属性值改变场次的放映时间。
public void setSchedule_startTime(String schedule_startTime) {
this.schedule_startTime = schedule_startTime;
}
// 获取该场次电影的售价
// Getter方法用于获取售价schedule_price可用于展示票价信息给用户或者在涉及价格计算、统计等业务操作中获取该场次的票价数据。
public int getSchedule_price() {
return schedule_price;
}
// 设置该场次电影的售价
// Setter方法用于设置售价schedule_price例如在修改场次票价时通过此方法更新场次对象的该属性值调整场次的价格信息。
public void setSchedule_price(int schedule_price) {
this.schedule_price = schedule_price;
}
// 获取该场次剩余的座位数量
// Getter方法用于获取剩余座位数schedule_remain在购票、退票等业务场景中实时获取座位剩余情况以决定是否可继续售票或者更新剩余座位数量等操作。
public int getSchedule_remain() {
return schedule_remain;
}
// 设置该场次剩余的座位数量
// Setter方法用于设置剩余座位数schedule_remain在有购票、退票等操作发生时通过此方法相应地更新场次对象的剩余座位数属性值保持数据的准确性。
public void setSchedule_remain(int schedule_remain) {
this.schedule_remain = schedule_remain;
}
// 获取所属放映厅对象
// Getter方法用于获取所属放映厅对象schedule_hall在需要获取放映厅详细信息如名称、座位布局等可以通过此方法获取对应的Hall对象进行相关操作。
public Hall getSchedule_hall() {
return schedule_hall;
}
// 设置所属放映厅对象
// Setter方法用于设置所属放映厅对象schedule_hall例如在关联场次与具体放映厅或者更新场次对应的放映厅时通过此方法设置属性值确保场次与正确的放映厅关联起来。
public void setSchedule_hall(Hall schedule_hall) {
this.schedule_hall = schedule_hall;
}
// 获取所有的订单集合
// Getter方法用于获取所有的订单集合orderList在统计场次收入、查询已购票用户等业务场景中可以通过此方法获取对应的订单列表进行相关操作。
public List<Order> getOrderList() {
return orderList;
}
// 设置所有的订单集合
// Setter方法用于设置所有的订单集合orderList一般在创建场次与订单的关联或者更新订单列表比如退票后更新相关订单状态等情况通过此方法设置属性值维护场次与订单之间的关系。
public void setOrderList(List<Order> orderList) {
this.orderList = orderList;
}
}

@ -1,51 +1,84 @@
package com.entity;
/**
*
*
* GetterSetter访
* 便
* @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;
}
}
// 用户的唯一标识符,在数据库中通常作为主键,用于唯一区分不同的用户记录。
private long user_id;
// 用户账号,用于用户登录等操作时的身份标识,一般是用户自定义的字符串形式的用户名。
private String user_name; //用户账号
// 用户密码,用于验证用户身份的保密信息,存储时通常需要进行加密处理以保障安全性(此处仅为简单的属性定义,实际应用中加密处理在其他地方实现)。
private String user_pwd; //用户密码
// 用户邮箱,用于接收系统相关通知、找回密码等功能的联系邮箱地址,方便与用户进行沟通及一些业务逻辑关联(如邮件验证等)。
private String user_email; //用户邮箱
// 用户权限用于区分不同角色的用户0表示普通会员具有普通的使用系统功能的权限1表示管理员拥有更多的管理系统相关的高级权限。
private int user_role; //用户权限 0普通会员 1管理员
// 用户头像地址,用于存储用户头像图片在服务器上的相对或绝对路径,方便在前端页面展示用户头像时根据此地址获取对应的图片资源。
private String user_headImg; //用户头像地址
// Getter方法用于获取用户的唯一标识符user_id外部代码可以通过调用此方法获取用户对象的该属性值遵循JavaBean规范。
public long getUser_id() {
return user_id;
}
// Setter方法用于设置用户的唯一标识符user_id外部代码可以通过调用此方法来修改用户对象的该属性值遵循JavaBean规范。
public void setUser_id(long user_id) {
this.user_id = user_id;
}
// Getter方法用于获取用户账号user_name方便在其他地方获取并使用此账号信息例如进行登录验证等操作时获取输入的账号与该值进行对比。
public String getUser_name() {
return user_name;
}
// Setter方法用于设置用户账号user_name例如在用户注册或者修改账号时通过此方法更新用户对象的账号属性值。
public void setUser_name(String user_name) {
this.user_name = user_name;
}
// Getter方法用于获取用户密码user_pwd不过在实际应用中直接获取密码可能需要遵循一定的安全规则比如仅在特定的验证场景下使用等。
public String getUser_pwd() {
return user_pwd;
}
// Setter方法用于设置用户密码user_pwd通常在用户修改密码或者注册新用户设置初始密码时调用此方法注意实际应用中密码应加密后存储。
public void setUser_pwd(String user_pwd) {
this.user_pwd = user_pwd;
}
// Getter方法用于获取用户邮箱user_email可以在需要发送邮件等与邮箱相关的业务场景中获取该邮箱地址使用。
public String getUser_email() {
return user_email;
}
// Setter方法用于设置用户邮箱user_email例如用户更新邮箱信息或者注册时填写邮箱时通过此方法设置属性值。
public void setUser_email(String user_email) {
this.user_email = user_email;
}
// Getter方法用于获取用户权限user_role在业务逻辑中可以根据此权限值判断用户所能进行的操作范围例如是否有管理功能权限等。
public int getUser_role() {
return user_role;
}
// Setter方法用于设置用户权限user_role一般在系统管理后台对用户角色进行调整等操作时使用此方法修改权限值。
public void setUser_role(int user_role) {
this.user_role = user_role;
}
// Getter方法用于获取用户头像地址user_headImg前端页面展示用户头像时可以根据此地址去获取对应的图片资源进行显示。
public String getUser_headImg() {
return user_headImg;
}
// Setter方法用于设置用户头像地址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>

@ -6,89 +6,16 @@ import org.springframework.stereotype.Repository;
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>

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

@ -14,198 +14,211 @@ import com.mapper.MovieMapper;
import com.mapper.UserMapper;
import com.service.IMovieService;
/**
* IMovieService
* Mapper
*
* @ServiceSpring便Spring
*/
@Service
public class MovieServiceImp implements IMovieService {
// 使用@Autowired注解自动注入MovieMapper接口用于调用数据库中与电影表相关的操作方法例如根据电影ID查询电影信息、添加电影、更新电影记录以及删除电影等操作。
@Autowired
private MovieMapper movieMapper; // 依赖注入 MovieMapper 用于执行与电影相关的数据库操作
private MovieMapper movieMapper;
// 自动注入CommentMapper接口用于操作评论相关的数据比如根据电影ID获取该电影对应的评论列表辅助电影相关业务逻辑处理因为电影与评论存在一对多的关联关系。
@Autowired
private CommentMapper commentMapper; // 依赖注入 CommentMapper 用于执行与评论相关的数据库操作
private CommentMapper commentMapper;
// 自动注入UserMapper接口用于获取用户相关信息在处理电影评论相关业务时需要根据评论中关联的用户ID查找用户详细信息以完善评论对象中的用户相关数据。
@Autowired
private UserMapper userMapper; // 依赖注入 UserMapper 用于执行与用户相关的数据库操作
private UserMapper userMapper;
/**
* ID
*
* @param movie_id ID
* @return Movie null
* ID
* 使Propagation.REQUIRED
* readOnly=true
* @param movie_id
* @return Movienull
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Movie findMovieById(long movie_id) {
// 首先通过MovieMapper根据电影ID从数据库中查询出基本的电影信息得到一个Movie对象。
Movie movie = this.movieMapper.findMovieById(movie_id);
// 通过CommentMapper根据电影ID查询该电影对应的所有评论列表信息得到一个Comment列表。
List<Comment> list = this.commentMapper.findCommentsByMoiveId(movie_id);
for (Comment comment : list) {
comment.setComment_user(this.userMapper.findUserById(comment.getUser_id())); // 设置评论的用户信息
// 对每条评论信息通过UserMapper根据评论中关联的用户ID查找并设置评论对象中的所属用户信息建立评论与用户的关联关系方便后续业务操作展示评论用户相关详情。
comment.setComment_user(this.userMapper.findUserById(comment.getUser_id()));
}
movie.setCommentList(list); // 设置电影的评论列表
// 将包含完整用户关联信息的评论列表设置到电影对象中,建立电影与评论的关联关系,使电影对象包含其对应的所有评论及相关用户信息,方便后续业务场景中展示电影详情页的评论等操作。
movie.setCommentList(list);
return movie;
}
/**
*
*
* @param price
* @param movie_id ID
* @return 10
*
* 使Propagation.REQUIRED
* rollbackForException.class
* @param price
* @param movie_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
*
* 使Propagation.REQUIREDreadOnly=true
* Movienull便使
* @param movie_cn_name
* @return Movienull
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@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
*
*
* @param movie_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
*
*
* @param movie_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
* Movie
* 使Propagation.REQUIRED
* rollbackForException.class
* @param movie Movie
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
*
* 使Propagation.REQUIRED
* rollbackForException.class
* @param movie_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
* Movie
* 使
* @param movie Movie
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer updateMovie(Movie movie) {
return this.movieMapper.updateMovie(movie);
}
/**
*
*
* @param movie_state
* @return Movie
* 线1线0
* 使Propagation.REQUIREDreadOnly=true
* 便使
* @param movie_state 线
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Movie> findAllMovies(int movie_state) {
return this.movieMapper.findAllMovies(movie_state);
}
/**
*
*
* @param name
* @return Movie
* 便
* 使Propagation.REQUIREDreadOnly=true
* 便使
* @param name
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Movie> findMoviesLikeName(String name) {
return this.movieMapper.findMoviesLikeName(name);
}
/**
*
*
* @param type
* @return Movie
* 便
* 使readOnly=truePropagation.REQUIRED
*
* @param type
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Movie> findMoviesLikeType(String type) {
return this.movieMapper.findMoviesLikeType(type);
}
/**
*
*
* @return Movie
* 便
* 使Propagation.REQUIREDreadOnly=true
* 便使
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Movie> sortMovieByDate() {
return this.movieMapper.sortMovieByDate();
}
/**
*
*
* @return Movie
* 便
* 使readOnly=truePropagation.REQUIRED
*
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Movie> sortMovieByCount() {
return this.movieMapper.sortMovieByCount();
}
/**
*
*
* @return Movie
* 便
* readOnly=truePropagation.REQUIRED
*
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@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();
}
}
* 便

@ -22,67 +22,59 @@ import com.mapper.UserMapper;
import com.service.IOrderService;
/**
* OrderServiceImpIOrderServiceOrder
* SpringMapperOrderMapperUserMapperScheduleMapperHallMapperMovieMapperCinemaMapperSpring
* `@Service`Spring便Spring使
* IOrderService
* Mapper
* 使便
* @ServiceSpring使Spring便
*/
@Service
public class OrderServiceImp implements IOrderService {
/**
* SpringOrderMapper
*/
// 使用@Autowired注解自动注入OrderMapper接口用于调用数据库中与订单表相关的操作方法例如根据订单ID查询订单、添加订单、更新订单状态等操作。
@Autowired
private OrderMapper orderMapper;
/**
* SpringUserMapper
*/
// 自动注入UserMapper接口用于获取用户相关信息在处理订单业务时需要根据订单关联的用户ID查找用户详细信息以完善订单对象中的用户相关数据。
@Autowired
private UserMapper userMapper;
/**
* SpringScheduleMapper
*/
// 自动注入ScheduleMapper接口用于操作场次相关的数据因为订单与场次存在关联关系需要通过场次ID查找场次详细信息并关联到订单对象中。
@Autowired
private ScheduleMapper scheduleMapper;
/**
* SpringHallMapper
*/
// 自动注入HallMapper接口用于获取放映厅相关信息辅助完善场次对象中的放映厅信息进而使订单对象能够关联到完整的场次及放映厅相关数据因为场次关联放映厅。
@Autowired
private HallMapper hallMapper;
/**
* SpringMovieMapper
*/
// 自动注入MovieMapper接口用于获取电影相关信息同样是为了完善场次对象中的电影信息最终使订单对象关联到完整的场次、放映厅及电影相关数据因为场次关联电影。
@Autowired
private MovieMapper movieMapper;
/**
* SpringCinemaMapper
*/
// 自动注入CinemaMapper接口用于获取影院相关信息以便在完善放映厅对象的所属影院信息时使用通过层层关联使订单对象能关联到完整的业务相关数据链条用户、订单、场次、放映厅、影院、电影
@Autowired
private CinemaMapper cinemaMapper;
/**
* ID
* `Propagation.REQUIRED``readOnly=true`
* OrderMapper`findOrderById`IDUserMapper`findUserById``null`
* @param order_id
* @return `Order``null`Mapper
* ID
* 使Propagation.REQUIRED
* readOnly=true
* @param order_id
* @return Ordernull
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Order findOrderById(String order_id) {
// 首先通过OrderMapper根据订单ID从数据库中查询出基本的订单信息得到一个Order对象。
Order order = this.orderMapper.findOrderById(order_id);
if (order!= null) {
// 通过UserMapper根据订单中关联的用户ID查找并设置订单对象中的所属用户信息建立订单与用户的关联关系方便后续业务操作获取用户详细信息。
order.setOrder_user(this.userMapper.findUserById(order.getUser_id()));
// 通过ScheduleMapper根据订单中关联的场次ID查找对应的场次信息得到一个Schedule对象。
Schedule schedule = this.scheduleMapper.findScheduleById(order.getSchedule_id());
// 根据场次中关联的放映厅ID通过HallMapper查询对应的放映厅信息得到一个Hall对象。
Hall hall = this.hallMapper.findHallById(schedule.getHall_id());
// 再通过CinemaMapper根据放映厅所属的影院ID查找并设置放映厅对象中的所属影院信息完善放映厅的关联信息。
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
// 将包含完整信息的放映厅对象设置到场次对象中,建立场次与放映厅的关联关系,方便后续业务操作获取放映厅详细信息。
schedule.setSchedule_hall(hall);
// 通过MovieMapper根据场次中关联的电影ID查找并设置场次对象中的放映电影信息建立场次与电影的关联关系以便获取电影详细信息。
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
// 将包含完整关联信息的场次对象设置到订单对象中,建立订单与场次的关联关系,使订单对象包含完整的业务关联信息链条。
order.setOrder_schedule(schedule);
} else {
order = null;
@ -91,18 +83,20 @@ public class OrderServiceImp implements IOrderService {
}
/**
* 退
* `Propagation.REQUIRED`
* OrderMapper`findRefundOrderByUserName`退0`findOrderById``null`
* @param user_name 退
* @return `Order``List`退退
* 退退
* 使readOnly=truePropagation.REQUIRED
* 0null退便退
* @param user_name 退
* @return 退null
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Order> findRefundOrderByUserName(String user_name) {
// 通过OrderMapper根据用户名查询该用户的所有可退款订单列表信息得到一个初始的订单列表。
List<Order> list = this.orderMapper.findRefundOrderByUserName(user_name);
if (list.size() > 0) {
for (Order order : list) {
// 对每个可退款订单信息进行关联信息的补充以下步骤与findOrderById方法中补充关联信息的逻辑类似依次查找并设置所属用户、所属场次及其关联的放映厅、电影等信息。
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());
@ -118,11 +112,11 @@ public class OrderServiceImp implements IOrderService {
}
/**
*
* `Propagation.REQUIRED``rollbackFor=Exception.class`
* OrderMapper`addOrder``Order`10
* @param order `Order`
* @return `Integer`
*
* 使Propagation.REQUIRED
* rollbackForException.class
* @param order Order
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
@ -131,11 +125,10 @@ public class OrderServiceImp implements IOrderService {
}
/**
* 退
* `Propagation.REQUIRED``rollbackFor=Exception.class`
* OrderMapper`updateOrderStateToRefund`order_id退10退
* @param order_id 退
* @return `Integer`
* 退
* 使
* @param order_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
@ -144,11 +137,10 @@ public class OrderServiceImp implements IOrderService {
}
/**
* 退
* 退退
* OrderMapper`updateOrderStateToRefunded`order_id退退
* @param order_id 退
* @return `Integer`
* 退
* 退退
* @param order_id 退
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
@ -157,20 +149,22 @@ public class OrderServiceImp implements IOrderService {
}
/**
*
* `Propagation.REQUIRED`
* `PageHelper.startPage(page, limit)`OrderMapper`findOrdersByUserName``PageInfo``PageInfo`便`PageInfo`
* @param page
* @param limit
* @param user_name
* @return `PageInfo<Order>`
*
* 使readOnly=truePropagation.REQUIREDPageHelperPageInfo
* @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设置分页参数指定当前页码和每页显示数量后续查询操作将按照此分页规则获取数据。
PageHelper.startPage(page, limit);
// 通过OrderMapper根据用户名查询符合条件的订单列表信息得到一个包含基本订单信息的列表。
List<Order> list = this.orderMapper.findOrdersByUserName(user_name);
for (Order order : list) {
// 对每个订单信息进行关联信息的补充以下步骤与findOrderById方法中补充关联信息的逻辑类似依次查找并设置所属用户、所属场次及其关联的放映厅、电影等信息。
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());
@ -179,21 +173,23 @@ public class OrderServiceImp implements IOrderService {
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
order.setOrder_schedule(schedule);
}
// 将包含完整关联信息的订单列表封装成PageInfo对象该对象包含了分页相关信息如总记录数、当前页码、每页数量等以及订单数据列表方便前端进行分页展示等操作。
PageInfo<Order> info = new PageInfo<Order>(list);
return info;
}
/**
*
* `Propagation.REQUIRED`
* OrderMapper`findAllOrders`便
* @return `Order``List`
*
* 使readOnly=true使便使
* @return
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public List<Order> findAllOrders() {
// 通过OrderMapper查询所有订单的基本信息得到一个初始的订单列表。
List<Order> list = this.orderMapper.findAllOrders();
for (Order order : list) {
// 对每个订单信息进行关联信息的补充以下步骤与findOrderById方法中补充关联信息的逻辑类似依次查找并设置所属用户、所属场次及其关联的放映厅、电影等信息。
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());
@ -206,13 +202,12 @@ public class OrderServiceImp implements IOrderService {
}
/**
*
* `Propagation.REQUIRED`
* `PageHelper.startPage(page, limit)`OrderMapper`findOrdersByState``PageInfo`便
* @param page
* @param limit
* @param order_state
* @return `PageInfo<Order>`
*
* PageInfo便
* @param page
* @param limit
* @param order_state 0退1
* @return PageInfo<Order>便
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
@ -233,10 +228,4 @@ public class OrderServiceImp implements IOrderService {
}
/**
*
* `Propagation.REQUIRED`
* `PageHelper.startPage(page, limit)`OrderMapper`findOrdersByUserName``findAllOrders``PageInfo`便
* @param page
* @param limit
* @param keyword `null`
* @return `PageInfo<Order>`
*

@ -19,232 +19,219 @@ import com.mapper.OrderMapper;
import com.mapper.ScheduleMapper;
import com.service.IScheduleService;
/**
* IScheduleService
* Mapper
* 使
* @ServiceSpring便
*/
@Service
public class ScheduleServiceImp implements IScheduleService {
// 使用@Autowired注解自动注入ScheduleMapper接口用于调用数据库中与场次表相关的操作方法比如根据ID查询场次、添加场次、更新场次等操作。
@Autowired
private ScheduleMapper scheduleMapper; // 依赖注入 ScheduleMapper 用于执行与排片相关的数据库操作
private ScheduleMapper scheduleMapper;
// 自动注入HallMapper接口用于操作放映厅相关的数据例如查询放映厅信息等辅助场次相关业务逻辑处理因为场次与放映厅存在关联关系。
@Autowired
private HallMapper hallMapper; // 依赖注入 HallMapper 用于执行与影厅相关的数据库操作
private HallMapper hallMapper;
// 自动注入MovieMapper接口用于获取电影相关信息比如根据电影ID查找电影详细信息等在处理场次业务时需要关联电影信息进行展示等操作。
@Autowired
private MovieMapper movieMapper; // 依赖注入 MovieMapper 用于执行与电影相关的数据库操作
private MovieMapper movieMapper;
// 自动注入OrderMapper接口用于查询与场次相关的订单信息例如查找某个场次下的所有订单方便在业务逻辑中涉及订单相关的操作如统计场次收入等
@Autowired
private OrderMapper orderMapper; // 依赖注入 OrderMapper 用于执行与订单相关的数据库操作
private OrderMapper orderMapper;
// 自动注入CinemaMapper接口用于获取影院相关信息比如查找放映厅所属的影院信息等因为场次关联放映厅放映厅又属于特定影院存在多层关联关系。
@Autowired
private CinemaMapper cinemaMapper; // 依赖注入 CinemaMapper 用于执行与影院相关的数据库操作
private CinemaMapper cinemaMapper;
/**
* ID
*
* @param schedule_id ID
* @return Schedule null
* ID
* 使Propagation.REQUIRED
* readOnly=true
* @param schedule_id
* @return Schedulenull
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public Schedule findScheduleById(long schedule_id) {
// 首先通过ScheduleMapper根据场次ID从数据库中查询出基本的场次信息得到一个Schedule对象。
Schedule schedule = this.scheduleMapper.findScheduleById(schedule_id);
// 根据场次中关联的放映厅ID通过HallMapper查询对应的放映厅信息得到一个Hall对象。
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())); // 设置排片的电影
// 再通过CinemaMapper根据放映厅所属的影院ID查找并设置放映厅对象中的所属影院信息完善放映厅的关联信息。
hall.setHall_cinema(this.cinemaMapper.findCinemaById(hall.getCinema_id()));
// 将包含完整信息的放映厅对象设置到场次对象中,建立场次与放映厅的关联关系,方便后续业务操作获取放映厅详细信息。
schedule.setSchedule_hall(hall);
// 通过MovieMapper根据场次中关联的电影ID查找并设置场次对象中的放映电影信息建立场次与电影的关联关系以便获取电影详细信息。
schedule.setSchedule_movie(this.movieMapper.findMovieById(schedule.getMovie_id()));
// 通过OrderMapper根据场次ID查找该场次下的所有订单信息得到一个订单列表设置到场次对象中方便后续统计订单相关数据等操作。
List<Order> list = this.orderMapper.findOrdersByScheduleId(schedule_id);
schedule.setOrderList(list); // 设置排片的订单列表
schedule.setOrderList(list);
return schedule;
}
/**
*
*
* @param schedule Schedule
* @return 10
*
* 使Propagation.REQUIRED
* rollbackForException.class
* @param schedule Schedule
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public Integer addSchedule(Schedule schedule) {
return this.scheduleMapper.addSchedule(schedule);
}
/**
* ID
*
* @param schedule Schedule
* @return 10
*
* 使
* @param schedule Schedule
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
* 使
*
* @param schedule_id
* @return 010
*/
/**
*
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
* 退
* 使
* @param schedule_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
*
* 使
* @param schedule_id
* @return 010
*/
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 写入操作,遇到异常时回滚
@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
*
* 使readOnly=truePropagation.REQUIRED
* PageHelperPageInfo
* @param page
* @param limit
* @param movie_name
* @return PageInfo<Schedule>便
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Schedule> findScheduleByMovieName(Integer page, Integer limit, String movie_name) {
PageHelper.startPage(page, limit); // 启用分页
// 使用PageHelper设置分页参数指定当前页码和每页显示数量后续查询操作将按照此分页规则获取数据。
PageHelper.startPage(page, limit);
// 通过ScheduleMapper根据电影名称查询符合条件的场次列表信息得到一个包含基本场次信息的列表。
List<Schedule> schedules = this.scheduleMapper.findScheduleByMovieName(movie_name);
for (Schedule schedule : schedules) {
// 对每个场次信息进行关联信息的补充以下步骤与findScheduleById方法中补充关联信息的逻辑类似依次查找并设置放映厅、电影、订单列表等关联信息。
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())); // 设置排片的电影
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); // 设置排片的订单列表
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
// 将包含完整关联信息的场次列表封装成PageInfo对象该对象包含了分页相关信息如总记录数、当前页码、每页数量等以及场次数据列表方便前端进行分页展示等操作。
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
/**
*
*
* @param page
* @param limit
* @param movie_name
* @return PageInfo
*
* findScheduleByMovieName使
* @param page
* @param limit
* @param movie_name
* @return PageInfo<Schedule>便
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Schedule> findOffScheduleByMovieName(Integer page, Integer limit, String movie_name) {
PageHelper.startPage(page, limit); // 启用分页
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())); // 设置排片的电影
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); // 设置排片的订单列表
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
/**
*
*
* @param page
* @param limit
* @param schedule_state
* @return PageInfo
*
* PageInfo
* @param page
* @param limit
* @param schedule_state 10
* @return PageInfo<Schedule>便
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Schedule> findAllScheduleByState(Integer page, Integer limit, int schedule_state) {
PageHelper.startPage(page, limit); // 启用分页
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())); // 设置排片的电影
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); // 设置排片的订单列表
schedule.setOrderList(list);
}
PageInfo<Schedule> info = new PageInfo<>(schedules);
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules);
return info;
}
/**
*
*
* @param page
* @param limit
* @return PageInfo
*
* PageInfo
* @param page
* @param limit
* @return PageInfo<Schedule>便
*/
@Transactional(propagation = Propagation.REQUIRED, readOnly = true) // 读取操作,不需要回滚
@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
@Override
public PageInfo<Schedule> findAllSchedule(Integer page, Integer limit) {
PageHelper.startPage(page, 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())); // 设置排片的电影
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())); // 设置排片的电影
schedule.setOrderList(list);
}
return list;
}
}
PageInfo<Schedule> info = new PageInfo<Schedule>(schedules

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

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

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