Introduction
This cinema ticket booking system is built using Java with the SSM framework and JSP technology. The system provides comprehensive functionality for managing movie screenings, ticket sales, and user accounts.
System Architecture
Backend Framework SpringBoot
Spring Boot serves as the foundation for building stand-alone, production-ready applications based on the Spring framework. It simplifies the development process by providing out-of-the-box features while maintaining the core strength and flexibility of Spring.
The framework follows the principle of "convention over configuration," reducing boilerplate code and allowing developers to focus on business logic implementation. Spring Boot includes embedded web servers like Tomcat, Undertow, or Jetty, enabling applications to be packaged as executable JAR files.
Frontend Framework Vue
Vue.js is a progressive JavaScript framework designed for building user interfaces and single-page applications. Created by Evan You in 2014, it offers a lightweight, aproachable, and flexible solution for frontend development.
Vue's reactive data binding system enables developers to manage view and data changes effortlessly. The component-based development model allows applications to be broken down into small, independent components that can be combined into complete applications.
Core Implementation Code
package com.cinema;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
@MapperScan(basePackages = {"com.cinema.dao"})
public class CinemaApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(CinemaApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(CinemaApplication.class);
}
}
package com.cinema.controller;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.cinema.utils.ValidationUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.cinema.annotation.PublicAccess;
import com.cinema.entity.UserEntity;
import com.cinema.entity.view.UserView;
import com.cinema.service.UserService;
import com.cinema.service.TokenService;
import com.cinema.utils.PageUtils;
import com.cinema.utils.Response;
import com.cinema.utils.MyBatisPlusUtil;
import com.cinema.utils.MapConverter;
import com.cinema.utils.CommonUtils;
import java.io.IOException;
/**
* User management controller
* Backend API endpoints
*/
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@Autowired
private TokenService tokenService;
/**
* User authentication endpoint
*/
@PublicAccess
@RequestMapping(value = "/authenticate")
public Response authenticate(String username, String password, String captcha, HttpServletRequest request) {
UserEntity user = userService.selectOne(new EntityWrapper<userentity>().eq("account_number", username));
if(user == null || !user.getPassword().equals(password)) {
return Response.error("Invalid credentials");
}
String token = tokenService.generateToken(user.getId(), username, "user", "User Account");
return Response.success().put("token", token);
}
/**
* User registration endpoint
*/
@PublicAccess
@RequestMapping("/register")
public Response register(@RequestBody UserEntity user) {
UserEntity existing = userService.selectOne(new EntityWrapper<userentity>().eq("account_number", user.getAccountNumber()));
if(existing != null) {
return Response.error("Account already exists");
}
Long userId = new Date().getTime();
user.setId(userId);
userService.insert(user);
return Response.success();
}
/**
* Logout functionality
*/
@RequestMapping("/signout")
public Response signOut(HttpServletRequest request) {
request.getSession().invalidate();
return Response.success("Successfully logged out");
}
/**
* Retrieve current session user info
*/
@RequestMapping("/current-session")
public Response getCurrentUserInfo(HttpServletRequest request) {
Long userId = (Long)request.getSession().getAttribute("userId");
UserEntity user = userService.selectById(userId);
return Response.success().put("data", user);
}
/**
* Password reset functionality
*/
@PublicAccess
@RequestMapping(value = "/password-reset")
public Response resetPassword(String username, HttpServletRequest request) {
UserEntity user = userService.selectOne(new EntityWrapper<userentity>().eq("account_number", username));
if(user == null) {
return Response.error("Account does not exist");
}
user.setPassword("123456");
userService.updateById(user);
return Response.success("Password reset to: 123456");
}
/**
* Admin panel listing
*/
@RequestMapping("/manage-list")
public Response adminList(@RequestParam Map<string object=""> parameters, UserEntity user,
HttpServletRequest request) {
EntityWrapper<userentity> wrapper = new EntityWrapper<userentity>();
PageUtils pageResult = userService.queryPage(parameters, MyBatisPlusUtil.sort(
MyBatisPlusUtil.between(MyBatisPlusUtil.likeOrEq(wrapper, user), parameters), parameters));
return Response.success().put("data", pageResult);
}
/**
* Public listing endpoint
*/
@PublicAccess
@RequestMapping("/public-list")
public Response publicList(@RequestParam Map<string object=""> parameters, UserEntity user,
HttpServletRequest request) {
EntityWrapper<userentity> wrapper = new EntityWrapper<userentity>();
PageUtils pageResult = userService.queryPage(parameters, MyBatisPlusUtil.sort(
MyBatisPlusUtil.between(MyBatisPlusUtil.likeOrEq(wrapper, user), parameters), parameters));
return Response.success().put("data", pageResult);
}
/**
* General listing endpoint
*/
@RequestMapping("/all-records")
public Response getAllRecords(UserEntity user) {
EntityWrapper<userentity> wrapper = new EntityWrapper<userentity>();
wrapper.allEq(MyBatisPlusUtil.allEQMapPre(user, "user"));
return Response.success().put("data", userService.selectListView(wrapper));
}
/**
* Search functionality
*/
@RequestMapping("/search")
public Response search(UserEntity user) {
EntityWrapper<userentity> wrapper = new EntityWrapper<userentity>();
wrapper.allEq(MyBatisPlusUtil.allEQMapPre(user, "user"));
UserView userView = userService.selectView(wrapper);
return Response.success("Search completed successfully").put("data", userView);
}
/**
* Admin detail view
*/
@RequestMapping("/admin-detail/{id}")
public Response adminDetail(@PathVariable("id") Long id) {
UserEntity user = userService.selectById(id);
return Response.success().put("data", user);
}
/**
* Public detail view
*/
@PublicAccess
@RequestMapping("/view-detail/{id}")
public Response viewDetail(@PathVariable("id") Long id) {
UserEntity user = userService.selectById(id);
return Response.success().put("data", user);
}
/**
* Admin record creation
*/
@RequestMapping("/create-record")
public Response createRecord(@RequestBody UserEntity user, HttpServletRequest request) {
if(userService.selectCount(new EntityWrapper<userentity>().eq("account_number", user.getAccountNumber())) > 0) {
return Response.error("Account already exists");
}
user.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
UserEntity existing = userService.selectOne(new EntityWrapper<userentity>().eq("account_number", user.getAccountNumber()));
if(existing != null) {
return Response.error("User already exists");
}
user.setId(new Date().getTime());
userService.insert(user);
return Response.success();
}
/**
* Public record addition
*/
@RequestMapping("/add-entry")
public Response addEntry(@RequestBody UserEntity user, HttpServletRequest request) {
if(userService.selectCount(new EntityWrapper<userentity>().eq("account_number", user.getAccountNumber())) > 0) {
return Response.error("Account already exists");
}
user.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
UserEntity existing = userService.selectOne(new EntityWrapper<userentity>().eq("account_number", user.getAccountNumber()));
if(existing != null) {
return Response.error("User already exists");
}
user.setId(new Date().getTime());
userService.insert(user);
return Response.success();
}
/**
* Update functionality
*/
@RequestMapping("/modify")
@Transactional
public Response modify(@RequestBody UserEntity user, HttpServletRequest request) {
if(userService.selectCount(new EntityWrapper<userentity>().ne("id", user.getId()).eq("account_number", user.getAccountNumber())) > 0) {
return Response.error("Account already exists");
}
userService.updateById(user);
return Response.success();
}
/**
* Delete functionality
*/
@RequestMapping("/remove")
public Response remove(@RequestBody Long[] ids) {
userService.deleteBatchIds(Arrays.asList(ids));
return Response.success();
}
}
</userentity></userentity></userentity></userentity></userentity></userentity></userentity></userentity></userentity></userentity></userentity></string></userentity></userentity></string></userentity></userentity></userentity>
System Testing
System testing aims to identify issues from multiple perspectives through functional testing to locate and correct system defects, ensuring the system operates without flaws. The testing process validates that the system meets customer requirements and addresses discovered problems promptly.
Testing Objectives
During the development cycle, system testing is an essential and patience-testing phase. Its importance lies in being the final safeguard for system quality and reliability, serving as the last inspection of the entire development process.
System testing primarily prevents user issues during operation and enhances user experience. To avoid impacting users, we must consider potential system problems from multiple angles and perspectives, discovering and resolving defects through various simulated scenarios.
Functional Testing
Functional module testing involves black-box testing methods including clicking, inputting boundary values, and validating required and optional fields. Test cases are written and executed according to their content, leading to testing conclusions.
Login functionality testing: When accessing the system, account and password validation points are verified. Users must input content matching stored database data. Error messages appear when incorrect information is entered. This interface also includes role-based permission validation.
Testing Conclusion
The system primarily uses black-box testing, simulating user interactions to implement various functions through test case writing and execution, ensuring correct system flow. System testing is essential and makes the system more robust, increasing its usability.
Testing verifies whether the system's functional modules meet initial design concepts and validates the logical correctness of each module. The system requires straightforward logic processing for user-friendly operation. The ultimate testing goal revolves around user experience, with all scenarios meeting user requirements and avoiding deviation from target objectives.