基于SSH框架的在线电影选座售票系统 - 源码深度解析

在数字化娱乐消费日益普及的背景下，影院票务系统面临着从传统线下模式向线上智能化转型的技术需求。传统的现场排队购票方式存在座位信息不透明、选座效率低下、高峰期拥堵严重等问题，亟需通过技术手段实现业务流程的数字化重构。影院星云票务平台采用成熟的SSH（Struts+Spring+Hibernate）框架技术栈，构建了一套完整的在线选座购票解决方案。

系统采用典型的三层架构设计，表现层使用Struts框架的Action类处理前端请求和页面导航，业务层通过Spring框架的IoC容器实现服务组件的依赖注入和事务管理，数据持久层则基于Hibernate的ORM机制实现对象关系映射。这种分层架构确保了系统的高内聚低耦合特性，为后续功能扩展和维护提供了良好的技术基础。

数据库设计架构分析 系统数据库包含7张核心表，通过精细化的外键关联设计确保数据一致性。其中场次表（schedules）的设计尤为关键，它作为连接电影、放映厅和订单的枢纽节点，承载着业务逻辑的核心数据关系。

CREATE TABLE schedules (
    schedule_id INT PRIMARY KEY AUTO_INCREMENT,
    movie_id INT NOT NULL,
    hall_id INT NOT NULL,
    show_time DATETIME NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    available_seats INT DEFAULT 0,
    FOREIGN KEY (movie_id) REFERENCES movies(movie_id),
    FOREIGN KEY (hall_id) REFERENCES halls(hall_id)
);

场次表通过movie_id和hall_id外键分别关联电影表和放映厅表，show_time字段精确记录放映时间，price字段支持动态票价策略。available_seats字段实时更新剩余座位数，为选座操作提供并发控制基础。这种设计使得系统能够灵活支持不同影片在不同影厅的多时段排片需求。

订单表（orders）的设计体现了复杂的业务状态管理需求：

CREATE TABLE orders (
    order_id VARCHAR(32) PRIMARY KEY,
    user_id INT NOT NULL,
    schedule_id INT NOT NULL,
    seat_info TEXT NOT NULL,
    total_amount DECIMAL(10,2) NOT NULL,
    status ENUM('pending','paid','cancelled','completed') DEFAULT 'pending',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    pay_time DATETIME,
    FOREIGN KEY (user_id) REFERENCES users(user_id),
    FOREIGN KEY (schedule_id) REFERENCES schedules(schedule_id)
);

订单表采用业务主键order_id，支持分布式环境下的订单号生成。status字段使用枚举类型明确界定订单生命周期，seat_info以JSON格式存储选座信息，这种设计既保证了座位数据的完整性，又避免了过度范式化带来的查询复杂度。create_time和pay_time的时间戳记录为业务统计和超时处理提供了数据支撑。

核心功能实现解析

动态选座功能通过前端JavaScript与后端Ajax的紧密协作实现。当用户选择特定场次后，系统通过Hibernate查询映射关系获取座位状态数据：

@Entity
@Table(name = "seats")
public class Seat {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer seatId;
    
    @ManyToOne
    @JoinColumn(name = "hall_id")
    private Hall hall;
    
    private String rowCode;
    private Integer columnNumber;
    private String seatType;
    
    // Getter和Setter方法
}

选座界面实时渲染放映厅座位布局，通过颜色区分可用、已选、已售等不同状态。当用户选择座位时，前端通过Ajax向后台发送异步请求：

function selectSeat(seatId) {
    $.ajax({
        url: 'seatAction!lockSeat',
        type: 'POST',
        data: {seatId: seatId, scheduleId: selectedSchedule},
        success: function(response) {
            if(response.success) {
                updateSeatStatus(seatId, 'selected');
                updateOrderSummary();
            } else {
                alert('选座失败：' + response.message);
            }
        }
    });
}

后端Struts Action接收请求后，通过Spring管理的Service层进行业务处理：

public class SeatAction extends ActionSupport {
    private SeatService seatService;
    private Integer seatId;
    private Integer scheduleId;
    private JSONResult result;
    
    public String lockSeat() {
        try {
            boolean success = seatService.lockSeat(seatId, scheduleId);
            result = JSONResult.success(success);
        } catch (BusinessException e) {
            result = JSONResult.error(e.getMessage());
        }
        return SUCCESS;
    }
    
    // Getter和Setter方法
}

Service层采用声明式事务管理，确保座位锁定操作的原子性：

@Service
@Transactional
public class SeatServiceImpl implements SeatService {
    @Autowired
    private SeatDAO seatDAO;
    
    @Override
    public boolean lockSeat(Integer seatId, Integer scheduleId) {
        SeatStatus status = seatDAO.getSeatStatus(seatId, scheduleId);
        if (status == SeatStatus.AVAILABLE) {
            return seatDAO.updateSeatStatus(seatId, scheduleId, SeatStatus.LOCKED);
        }
        throw new BusinessException("座位不可用");
    }
}

订单支付流程整合了状态机模式和策略模式。当用户确认选座信息后，系统生成待支付订单，并启动支付超时计时器：

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderDAO orderDAO;
    @Autowired
    private PaymentStrategyFactory paymentFactory;
    
    @Override
    public Order createOrder(OrderDTO orderDTO) {
        Order order = new Order();
        order.setOrderId(generateOrderId());
        order.setUserId(orderDTO.getUserId());
        order.setScheduleId(orderDTO.getScheduleId());
        order.setSeatInfo(JSON.toJSONString(orderDTO.getSeats()));
        order.setTotalAmount(calculateTotal(orderDTO.getSeats()));
        order.setStatus(OrderStatus.PENDING);
        
        orderDAO.save(order);
        startPaymentTimer(order.getOrderId());
        return order;
    }
    
    @Override
    public boolean processPayment(String orderId, String paymentType) {
        PaymentStrategy strategy = paymentFactory.getStrategy(paymentType);
        PaymentResult result = strategy.pay(orderId);
        if (result.isSuccess()) {
            return updateOrderStatus(orderId, OrderStatus.PAID);
        }
        return false;
    }
}

影院管理后台提供完整的影片排期和票务管理功能。影片管理模块支持影片信息的CRUD操作，并与场次安排形成联动：

@Controller
@RequestMapping("/admin/movie")
public class MovieAdminController {
    @Autowired
    private MovieService movieService;
    
    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public String addMovie(@ModelAttribute Movie movie, 
                          @RequestParam MultipartFile poster) {
        if (!poster.isEmpty()) {
            String posterPath = saveUploadFile(poster);
            movie.setPosterUrl(posterPath);
        }
        movieService.addMovie(movie);
        return "redirect:/admin/movie/list";
    }
    
    @RequestMapping("/schedule/{movieId}")
    public ModelAndView viewSchedules(@PathVariable Integer movieId) {
        List<Schedule> schedules = scheduleService.getSchedulesByMovie(movieId);
        ModelAndView mav = new ModelAndView("admin/movie_schedules");
        mav.addObject("schedules", schedules);
        return mav;
    }
}

用户评价系统采用双向关联设计，支持用户对已观看影片进行评分和评论：

@Entity
@Table(name = "reviews")
public class Review {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer reviewId;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user;
    
    @ManyToOne
    @JoinColumn(name = "movie_id")
    private Movie movie;
    
    private Integer rating;
    private String content;
    private Date createTime;
    
    // Getter和Setter方法
}

评价查询通过Hibernate的HQL实现复杂关联查询：

@Repository
public class ReviewDAOImpl extends HibernateDaoSupport implements ReviewDAO {
    public List<Review> getMovieReviews(Integer movieId, int page, int size) {
        String hql = "FROM Review r WHERE r.movie.movieId = :movieId " +
                    "ORDER BY r.createTime DESC";
        return getHibernateTemplate().execute(session -> 
            session.createQuery(hql, Review.class)
                  .setParameter("movieId", movieId)
                  .setFirstResult((page - 1) * size)
                  .setMaxResults(size)
                  .list());
    }
}

实体模型设计策略

系统实体模型采用面向对象的设计原则，通过注解配置实现对象关系映射。用户实体（User）设计包含身份验证和业务关联：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer userId;
    
    @Column(unique = true, nullable = false)
    private String username;
    
    private String password;
    private String email;
    private String phone;
    private String realName;
    private Date registerTime;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private Set<Order> orders = new HashSet<>();
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private Set<Review> reviews = new HashSet<>();
    
    // Getter和Setter方法
}

这种设计通过一对多关联映射实现了用户与订单、评价的业务关系，cascade配置确保了数据操作的级联效果。

系统优化与扩展方向

在现有功能基础上，系统可从以下几个方向进行深度优化：

分布式会话管理方面，可引入Redis集群替代HttpSession，实现用户状态的跨节点共享。通过Spring Session框架整合Redis，配置如下：

@Configuration
@EnableRedisHttpSession
public class RedisSessionConfig {
    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory();
    }
}

座位库存管理可引入缓存机制，将热门场次的座位状态缓存至Redis，减少数据库访问压力。采用Redis的位图结构存储座位状态，每个场次对应一个bitmap，每位代表一个座位的可用状态：

@Service
public class SeatCacheService {
    private static final String KEY_PREFIX = "seat:";
    
    @Autowired
    private RedisTemplate<String, byte[]> redisTemplate;
    
    public void cacheSeatStatus(Integer scheduleId, List<SeatStatus> statusList) {
        String key = KEY_PREFIX + scheduleId;
        Bitmap bitmap = new Bitmap(statusList.size());
        for (int i = 0; i < statusList.size(); i++) {
            bitmap.set(i, statusList.get(i) == SeatStatus.AVAILABLE);
        }
        redisTemplate.opsForValue().set(key, bitmap.toByteArray());
    }
}

支付渠道整合方面，可设计可插拔的支付网关接口，支持支付宝、微信支付等多种支付方式。通过策略模式实现支付渠道的动态切换：

public interface PaymentGateway {
    PaymentResult pay(PaymentRequest request);
    PaymentResult query(String orderId);
    boolean refund(RefundRequest request);
}

@Service
public class AlipayGateway implements PaymentGateway {
    @Override
    public PaymentResult pay(PaymentRequest request) {
        // 支付宝支付实现
    }
}

大数据分析功能可通过构建数据仓库实现观影偏好分析。建立独立的分析数据库，定期从业务数据库ETL数据，使用维度建模技术构建星型模式：

-- 观影事实表
CREATE TABLE fact_movie_viewing (
    fact_id BIGINT PRIMARY KEY,
    user_id INT,
    movie_id INT,
    schedule_id INT,
    cinema_id INT,
    viewing_date DATE,
    ticket_price DECIMAL(10,2),
    seat_type VARCHAR(20)
);

推荐算法集成可基于协同过滤和内容过滤实现个性化推荐。使用Mahout或Spark MLlib构建推荐引擎：

public class MovieRecommender {
    public List<Movie> recommend(User user, int maxResults) {
        // 基于用户历史行为和相似用户偏好生成推荐列表
    }
}

高并发场景下，可引入消息队列处理订单创建和库存更新操作。使用RabbitMQ或Kafka实现异步处理：

@Component
public class OrderMessageProducer {
    @Autowired
    private AmqpTemplate rabbitTemplate;
    
    public void sendOrderCreateMessage(Order order) {
        rabbitTemplate.convertAndSend("order.create", order);
    }
}

@Component
public class OrderMessageConsumer {
    @RabbitListener(queues = "order.create")
    public void handleOrderCreate(Order order) {
        // 处理订单创建后的后续操作
    }
}

影院星云票务平台通过SSH框架的有机整合，构建了稳定可靠的在线选座购票系统。系统架构清晰，模块划分合理，为后续的功能扩展和性能优化奠定了坚实的技术基础。随着业务规模的扩大和技术演进，系统可通过引入分布式架构、缓存策略、异步处理等机制进一步提升系统性能和用户体验。