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

SSH框架JavaJavaScriptHTMLCSSMySQLJSP+Servlet
2026-02-224 浏览

文章摘要

本项目是一款基于SSH（Struts2 + Spring + Hibernate）整合框架开发的电影在线订票系统，旨在为影院提供一体化的电影放映管理与在线票务服务。系统核心解决了传统线下购票流程繁琐、影厅座位信息不透明、影院排片与票务数据管理分散等痛点，通过线上化服务帮助影院提升运营效率，同时为用户...

在电影产业数字化浪潮的推动下，传统影院运营模式正面临深刻变革。一款基于SSH（Struts2 + Spring + Hibernate）整合框架构建的“银幕云”在线票务平台，通过技术手段系统性地解决了线下购票流程冗长、座位信息不透明、排片与票务管理割裂等行业痛点。该平台采用经典的三层架构设计，实现了业务逻辑的高内聚、低耦合，为影院管理者与终端用户提供了高效、直观的操作体验。

系统架构与技术栈解析

平台的技术选型体现了企业级应用的成熟度与稳定性。表现层采用Struts2框架处理前端请求与页面路由，其强大的拦截器机制与标签库为表单验证与数据展示提供了坚实基础。业务逻辑层由Spring框架全面接管，通过控制反转（IoC）容器实现服务组件的依赖注入，结合声明式事务管理确保购票、排片等核心操作的数据一致性。数据持久层依托Hibernate实现对象关系映射（ORM），将Java实体类与数据库表结构无缝衔接，通过HQL（Hibernate Query Language）完成复杂查询操作。

技术栈的协同工作流程如下：用户请求通过Struts2的FilterDispatcher进入系统，由配置在struts.xml中的Action映射接收参数；Action调用由Spring管理的Service层业务组件；Service层通过Hibernate的SessionFactory获取数据库会话，执行持久化操作。这种分层架构使各层职责清晰，便于单元测试与功能扩展。

数据库架构设计与核心表分析

系统共设计9张数据表，围绕影院业务的核心实体建立关系模型。以下重点分析三个关键表的结构设计：

1. 场次表（schedule）设计

CREATE TABLE `schedule` (
  `schedule_id` int(11) NOT NULL AUTO_INCREMENT,
  `movie_id` int(11) NOT NULL,
  `cinema_hall_id` int(11) NOT NULL,
  `show_time` datetime NOT NULL,
  `price` decimal(10,2) NOT NULL,
  `remaining_seats` int(11) NOT NULL DEFAULT 0,
  PRIMARY KEY (`schedule_id`),
  KEY `fk_schedule_movie` (`movie_id`),
  KEY `fk_schedule_hall` (`cinema_hall_id`),
  CONSTRAINT `fk_schedule_movie` FOREIGN KEY (`movie_id`) 
    REFERENCES `movie` (`movie_id`) ON DELETE CASCADE,
  CONSTRAINT `fk_schedule_hall` FOREIGN KEY (`cinema_hall_id`) 
    REFERENCES `cinema_hall` (`cinema_hall_id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

该表设计亮点在于通过双外键约束实现数据完整性：movie_id关联影片基本信息，cinema_hall_id关联放映影厅。show_time字段采用datetime类型精确到分钟，支持按时间区间检索。remaining_seats字段实时记录可用座位数，为高并发订票场景提供乐观锁基础。索引策略针对常见查询场景优化，如按影片检索场次（movie_id索引）、按影厅排期查询（cinema_hall_id索引）。

2. 订单表（ticket_order）设计

CREATE TABLE `ticket_order` (
  `order_id` varchar(32) NOT NULL,
  `user_id` int(11) NOT NULL,
  `schedule_id` int(11) NOT NULL,
  `seat_numbers` varchar(255) NOT NULL,
  `total_amount` decimal(10,2) NOT NULL,
  `order_status` tinyint(4) NOT NULL DEFAULT 0,
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `pay_time` datetime DEFAULT NULL,
  PRIMARY KEY (`order_id`),
  KEY `idx_user_status` (`user_id`,`order_status`),
  KEY `idx_create_time` (`create_time`),
  CONSTRAINT `fk_order_schedule` FOREIGN KEY (`schedule_id`) 
    REFERENCES `schedule` (`schedule_id`) ON DELETE RESTRICT
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

订单表采用业务主键设计，order_id使用32位字符串（如UUID）避免自增ID暴露业务量。seat_numbers字段以JSON格式存储选购的座位号（如["A01","A02"]），既保证数据结构化又避免关联表查询开销。索引设计极具针对性：idx_user_status复合索引支持用户中心快速查询订单列表，idx_create_time索引便于按时间维度统计销售数据。order_status字段通过tinyint实现状态机（0-待支付、1-已支付、2-已取消），配合pay_time字段精确追踪支付流程。

3. 影厅座位表（hall_seat）设计

CREATE TABLE `hall_seat` (
  `seat_id` int(11) NOT NULL AUTO_INCREMENT,
  `cinema_hall_id` int(11) NOT NULL,
  `row_num` char(2) NOT NULL,
  `col_num` int(11) NOT NULL,
  `seat_type` tinyint(4) NOT NULL DEFAULT 1,
  `is_active` tinyint(1) NOT NULL DEFAULT 1,
  PRIMARY KEY (`seat_id`),
  UNIQUE KEY `uk_hall_seat` (`cinema_hall_id`,`row_num`,`col_num`),
  CONSTRAINT `fk_seat_hall` FOREIGN KEY (`cinema_hall_id`) 
    REFERENCES `cinema_hall` (`cinema_hall_id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

该表通过唯一约束uk_hall_seat确保同一影厅内座位坐标不重复。seat_type字段支持差异化票价（1-普通座、2-VIP座），is_active字段实现座位软删除，避免物理删除导致历史订单数据引用异常。行列编号分离存储（row_num为字符型处理字母排号，col_num为数字型）便于生成可视化座位图。

核心功能实现深度解析

1. 动态座位渲染与实时锁定机制

前端座位图根据影厅实际布局动态生成，通过Ajax请求获取指定场次的可用座位数据。当用户选择座位时，系统通过WebSocket连接实时推送座位状态变更，避免多用户同时选择同一座位的冲突。

// 座位选择前端控制逻辑
function initSeatMap(hallId, scheduleId) {
    $.get('/seatMap?scheduleId=' + scheduleId, function(data) {
        var seatMap = JSON.parse(data);
        var html = '';
        for (var row in seatMap.layout) {
            html += '<div class="seat-row">';
            for (var col in seatMap.layout[row]) {
                var seat = seatMap.layout[row][col];
                var statusClass = seat.status == 'available' ? 'available' : 
                                 (seat.status == 'locked' ? 'locked' : 'sold');
                html += '<div class="seat ' + statusClass + '" data-row="' + row + 
                       '" data-col="' + col + '" onclick="selectSeat(this)">' + 
                       row + col + '</div>';
            }
            html += '</div>';
        }
        $('#seat-container').html(html);
    });
}

// WebSocket座位状态监听
var socket = new WebSocket('/seatLock');
socket.onmessage = function(event) {
    var msg = JSON.parse(event.data);
    if (msg.type == 'seatLocked') {
        $('.seat[data-row="' + msg.row + '"][data-col="' + msg.col + '"]')
            .removeClass('available').addClass('locked');
    }
};

后端通过Hibernate乐观锁控制座位库存，在用户开始选座时临时锁定座位，设置超时释放机制：

@Service
@Transactional
public class SeatSelectionService {
    @Autowired
    private ScheduleDao scheduleDao;
    
    public boolean lockSeats(Integer scheduleId, List<String> seatNumbers) {
        Schedule schedule = scheduleDao.get(scheduleId);
        if (schedule.getRemainingSeats() < seatNumbers.size()) {
            return false;
        }
        
        // 验证座位是否可用并临时锁定
        for (String seatNum : seatNumbers) {
            SeatLock lock = new SeatLock(scheduleId, seatNum, 
                new Date(), LockStatus.TEMPORARY);
            seatLockDao.save(lock);
        }
        
        // 启动定时任务，15分钟后自动释放锁定
        scheduleLockRelease(scheduleId, seatNumbers);
        return true;
    }
}

2. 事务性订单处理流程

购票操作涉及多个数据表的原子性更新，通过Spring的声明式事务管理确保数据一致性：

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderDao orderDao;
    @Autowired
    private ScheduleDao scheduleDao;
    @Autowired
    private SeatLockDao seatLockDao;
    
    @Transactional(rollbackFor = Exception.class)
    public OrderResult createOrder(OrderRequest request) {
        // 1. 验证座位锁定状态
        for (String seatNum : request.getSeatNumbers()) {
            SeatLock lock = seatLockDao.findLock(request.getScheduleId(), seatNum);
            if (lock == null || !lock.getUserId().equals(request.getUserId())) {
                throw new SeatNotLockedException("座位未被锁定");
            }
        }
        
        // 2. 创建订单记录
        TicketOrder order = new TicketOrder();
        order.setOrderId(GenerateOrderIdUtil.generate());
        order.setUserId(request.getUserId());
        order.setScheduleId(request.getScheduleId());
        order.setSeatNumbers(JSON.toJSONString(request.getSeatNumbers()));
        order.setTotalAmount(calculateTotal(request.getSeatNumbers().size()));
        orderDao.save(order);
        
        // 3. 更新场次座位库存
        Schedule schedule = scheduleDao.get(request.getScheduleId());
        schedule.setRemainingSeats(schedule.getRemainingSeats() - 
            request.getSeatNumbers().size());
        scheduleDao.update(schedule);
        
        // 4. 将临时锁定转为永久占用
        seatLockDao.convertToPermanent(request.getScheduleId(), 
            request.getSeatNumbers());
            
        return new OrderResult(order.getOrderId(), order.getTotalAmount());
    }
}

订单创建流程图 图示：订单创建涉及的多表操作与事务边界

3. 智能排片冲突检测

影院管理员排片时，系统通过HQL查询检测同一影厅的时间段重叠冲突：

@Repository
public class ScheduleDaoImpl extends HibernateDaoSupport implements ScheduleDao {
    
    public boolean hasScheduleConflict(Integer hallId, Date startTime, Date endTime) {
        String hql = "SELECT COUNT(s) FROM Schedule s WHERE s.cinemaHall.hallId = :hallId " +
                    "AND ((s.showTime BETWEEN :startTime AND :endTime) " +
                    "OR (s.endTime BETWEEN :startTime AND :endTime) " +
                    "OR (:startTime BETWEEN s.showTime AND s.endTime))";
        
        Long count = (Long) getHibernateTemplate().findByNamedParam(hql, 
            new String[]{"hallId", "startTime", "endTime"}, 
            new Object[]{hallId, startTime, endTime}).get(0);
            
        return count > 0;
    }
    
    // 计算场次结束时间（影片时长+清洁间隔）
    public Date calculateEndTime(Date startTime, Integer movieDuration) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(startTime);
        cal.add(Calendar.MINUTE, movieDuration + 30); // 30分钟清洁时间
        return cal.getTime();
    }
}

4. 多维度影片检索策略

影片查询功能支持按名称、类型、上映日期等多条件组合检索，通过Struts2的ModelDriven机制接收参数：

public class MovieSearchAction extends ActionSupport implements ModelDriven<MovieCriteria> {
    private MovieCriteria criteria = new MovieCriteria();
    private List<Movie> movieList;
    
    @Autowired
    private MovieService movieService;
    
    public String execute() {
        movieList = movieService.searchMovies(criteria);
        return SUCCESS;
    }
    
    // 参数验证
    public void validate() {
        if (criteria.getReleaseDateFrom() != null && 
            criteria.getReleaseDateTo() != null &&
            criteria.getReleaseDateFrom().after(criteria.getReleaseDateTo())) {
            addFieldError("releaseDateFrom", "开始日期不能晚于结束日期");
        }
    }
    
    public MovieCriteria getModel() { return criteria; }
    public List<Movie> getMovieList() { return movieList; }
}

对应的Hibernate动态查询实现：

@Repository
public class MovieDaoImpl extends HibernateDaoSupport implements MovieDao {
    
    public List<Movie> findByCriteria(MovieCriteria criteria) {
        StringBuilder hql = new StringBuilder("FROM Movie m WHERE 1=1");
        Map<String, Object> params = new HashMap<>();
        
        if (StringUtils.isNotBlank(criteria.getKeyword())) {
            hql.append(" AND (m.title LIKE :keyword OR m.director LIKE :keyword)");
            params.put("keyword", "%" + criteria.getKeyword() + "%");
        }
        
        if (criteria.getGenre() != null) {
            hql.append(" AND m.genre = :genre");
            params.put("genre", criteria.getGenre());
        }
        
        if (criteria.getReleaseDateFrom() != null) {
            hql.append(" AND m.releaseDate >= :fromDate");
            params.put("fromDate", criteria.getReleaseDateFrom());
        }
        
        // 执行分页查询
        Query query = getSession().createQuery(hql.toString());
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            query.setParameter(entry.getKey(), entry.getValue());
        }
        
        query.setFirstResult((criteria.getPage() - 1) * criteria.getPageSize());
        query.setMaxResults(criteria.getPageSize());
        
        return query.list();
    }
}

影片检索界面 图示：支持多条件筛选的影片查询界面

实体模型与关系映射

系统通过Hibernate注解实现对象关系映射，以下以核心实体为例展示映射策略：

@Entity
@Table(name = "movie")
public class Movie {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer movieId;
    
    @Column(nullable = false, length = 100)
    private String title;
    
    @Column(length = 500)
    private String description;
    
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Genre genre;
    
    @Column(nullable = false)
    private Integer duration; // 分钟
    
    @Temporal(TemporalType.DATE)
    private Date releaseDate;
    
    @OneToMany(mappedBy = "movie", cascade = CascadeType.ALL)
    private Set<Schedule> schedules = new HashSet<>();
    
    // 省略getter/setter
}

@Entity
@Table(name = "schedule")
public class Schedule {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer scheduleId;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "movie_id", nullable = false)
    private Movie movie;
    
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "cinema_hall_id", nullable = false)
    private CinemaHall cinemaHall;
    
    @Temporal(TemporalType.TIMESTAMP)
    @Column(nullable = false)
    private Date showTime;
    
    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;
    
    @Version
    private Integer version; // 乐观锁版本字段
    
    // 计算属性：场次结束时间
    @Transient
    public Date getEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(showTime);
        cal.add(Calendar.MINUTE, movie.getDuration() + 30);
        return cal.getTime();
    }
}

性能优化与实践经验

数据库连接池配置：通过Spring集成C3P0连接池，设置合理的初始连接数、最大连接数及超时参数，避免连接泄漏。

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <property name="initialPoolSize" value="5"/>
    <property name="maxPoolSize" value="50"/>
    <property name="checkoutTimeout" value="30000"/>
</bean>

二级缓存策略：对静态数据如影片信息、影厅结构启用Hibernate二级缓存，减少数据库访问频次：

@Entity
@Table(name = "movie")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Movie {
    // 实体定义
}

事务隔离级别控制：针对高并发订票场景，在Service层方法上设置适当的事务隔离级别：

@Transactional(isolation = Isolation.READ_COMMITTED, 
               propagation = Propagation.REQUIRED)
public class BookingService {
    // 业务方法
}

未来功能扩展方向

  1. 分布式会话管理：引入Redis集群实现用户会话共享，支持系统水平扩展与负载均衡。将会话数据从服务器内存迁移至Redis，通过Spring Session配置实现无缝切换。

  2. 微服务架构重构：将单体应用拆分为影片服务、订单服务、用户服务等独立微服务。使用Spring Cloud体系实现服务注册发现、配置中心与API网关，提升系统弹性与可维护性。

  3. 实时数据分析看板：集成Elasticsearch存储业务数据，通过Kibana构建可视化监控看板。实时展示票房趋势、上座率分析、热门影片排行等业务指标，为运营决策提供数据支持。

  4. 移动端原生应用：基于React Native开发跨平台移动应用，提供扫码检票、座位导航、观影提醒等增强功能。通过RESTful API与后端服务交互，确保数据一致性。

  5. 智能推荐引擎：基于用户历史购票记录与影片标签数据，实现协同过滤推荐算法。为用户个性化推荐可能感兴趣的影片，提升用户粘性与转化率。

该系统通过严谨的架构设计与深入的技术实现，为影院行业提供了完整的数字化

本文关键词
SSH框架电影订票系统源码解析在线订票平台系统架构

上下篇

上一篇
没有更多文章
下一篇
没有更多文章