基于Python+Django的酒店推荐系统设计与实现：前后端分离的客房预订管理平台|计算机毕业设计

一、个人简介

• 💖💖作者：计算机编程果茶熊
• 💙💙个人简介：曾长期从事计算机专业培训教学，担任过编程老师，同时本人也热爱上课教学，擅长Java、微信小程序、Python、Golang、安卓Android等多个IT方向。会做一些项目定制化开发、代码讲解、答辩教学、文档编写、也懂一些降重方面的技巧。平常喜欢分享一些自己开发中遇到的问题的解决办法，也喜欢交流技术，大家有技术代码这一块的问题可以问我！
• 💛💛想说的话：感谢大家的关注与支持！
• 💕💕文末获取源码联系计算机编程果茶熊

二、前言

• 本酒店推荐系统是一款基于B/S架构开发的综合性酒店管理平台，采用Java/Python双语言支持，分别基于SpringBoot(Spring+SpringMVC+Mybatis)和Django框架实现后端逻辑，前端采用Vue+ElementUI+HTML技术栈构建友好的用户界面，数据持久层使用MySQL数据库。系统功能模块完整，包括用户管理、客房类型管理、酒店客房信息管理、客房预定服务、入住登记处理、续订操作、退房结算、留言反馈收集、系统管理配置以及个人资料维护等核心功能，为酒店运营提供全方位的信息化支持。通过该系统，酒店管理人员可以高效地进行客房资源调配，用户可以便捷地查询、预订客房并进行相关操作，系统自动化处理入住、续订和退房流程，大幅提升了酒店运营效率和客户满意度。该系统界面直观、操作简便，功能模块间衔接紧密，数据流转顺畅，为酒店提供了一站式的信息管理解决方案。
• 近年来，我国旅游住宿业蓬勃发展，据文化和旅游部数据显示，2023年国内旅游人数达62.5亿人次，同比增长35.7%，住宿业收入突破7500亿元。然而，中国饭店协会发布的《2023年中国酒店业发展报告》指出，国内中小型酒店信息化程度普遍偏低，约65%的酒店仍依赖传统人工管理模式，导致预订错误率高达12%，客房资源利用率平均仅为68%。传统酒店管理方式存在信息不对称、预订流程繁琐、管理效率低下等问题，难以满足现代游客对便捷住宿服务的需求。在数字化转型浪潮下，酒店行业亟需一套完善的信息管理系统来提升运营效率和客户体验，这正是本酒店推荐系统设计的现实背景。
• 开发语言：Java+Python
• 数据库：MySQL
• 系统架构：B/S
• 后端框架：SpringBoot(Spring+SpringMVC+Mybatis)+Django
• 前端：Vue+HTML+CSS+JavaScript+jQuery

三、酒店推荐系统-视频解说

基于Python+Django的酒店推荐系统设计与实现：前后端分离的客房预订管理平台

四、酒店推荐系统-功能介绍

五、酒店推荐系统-代码展示

// 核心功能1: 客房预订处理 public ResponseEntity<Map<String, Object>> createReservation(@RequestBody ReservationDTO reservationDTO) { try { // 参数校验 if (reservationDTO.getRoomId() == null || reservationDTO.getUserId() == null || reservationDTO.getCheckInDate() == null || reservationDTO.getCheckOutDate() == null) { return ResponseEntity.badRequest().body(Collections.singletonMap("message", "预订信息不完整")); }

    // 检查日期有效性
    LocalDate checkInDate = reservationDTO.getCheckInDate();
    LocalDate checkOutDate = reservationDTO.getCheckOutDate();
    if (checkInDate.isBefore(LocalDate.now()) || checkOutDate.isBefore(checkInDate)) {
        return ResponseEntity.badRequest().body(Collections.singletonMap("message", "预订日期无效"));
    }
    
    // 检查客房是否可用
    Room room = roomRepository.findById(reservationDTO.getRoomId()).orElse(null);
    if (room == null) {
        return ResponseEntity.notFound().build();
    }
    
    // 检查该时间段是否已被预订
    List<Reservation> conflictingReservations = reservationRepository.findConflictingReservations(
            reservationDTO.getRoomId(), checkInDate, checkOutDate);
    if (!conflictingReservations.isEmpty()) {
        return ResponseEntity.badRequest().body(Collections.singletonMap("message", "所选时间段该客房已被预订"));
    }
    
    // 计算预订总价
    int days = (int) ChronoUnit.DAYS.between(checkInDate, checkOutDate);
    BigDecimal totalPrice = room.getPricePerNight().multiply(new BigDecimal(days));
    
    // 创建预订记录
    Reservation reservation = new Reservation();
    reservation.setRoomId(reservationDTO.getRoomId());
    reservation.setUserId(reservationDTO.getUserId());
    reservation.setCheckInDate(checkInDate);
    reservation.setCheckOutDate(checkOutDate);
    reservation.setTotalPrice(totalPrice);
    reservation.setStatus("PENDING");
    reservation.setCreatedAt(LocalDateTime.now());
    
    // 保存预订并更新房间状态
    Reservation savedReservation = reservationRepository.save(reservation);
    room.setStatus("RESERVED");
    roomRepository.save(room);
    
    // 发送预订确认邮件
    User user = userRepository.findById(reservationDTO.getUserId()).orElse(null);
    if (user != null && user.getEmail() != null) {
        emailService.sendReservationConfirmation(user.getEmail(), savedReservation, room);
    }
    
    return ResponseEntity.ok(Collections.singletonMap("reservation", savedReservation));
} catch (Exception e) {
    logger.error("预订处理失败", e);
    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(Collections.singletonMap("message", "预订处理失败: " + e.getMessage()));
}

}

// 核心功能2: 入住登记处理 public ResponseEntity<Map<String, Object>> checkIn(@RequestBody CheckInDTO checkInDTO) { try { // 验证预订信息 Reservation reservation = reservationRepository.findById(checkInDTO.getReservationId()).orElse(null); if (reservation == null) { return ResponseEntity.notFound().build(); }

    // 验证预订状态
    if (!"PENDING".equals(reservation.getStatus()) && !"CONFIRMED".equals(reservation.getStatus())) {
        return ResponseEntity.badRequest().body(
            Collections.singletonMap("message", "该预订无法办理入住，当前状态: " + reservation.getStatus()));
    }
    
    // 验证入住日期
    LocalDate today = LocalDate.now();
    if (today.isBefore(reservation.getCheckInDate())) {
        return ResponseEntity.badRequest().body(
            Collections.singletonMap("message", "尚未到达预订的入住日期"));
    }
    
    // 验证客人身份信息
    if (checkInDTO.getIdNumber() == null || checkInDTO.getIdNumber().trim().isEmpty()) {
        return ResponseEntity.badRequest().body(
            Collections.singletonMap("message", "需要提供有效的身份证号码"));
    }
    
    // 创建入住记录
    CheckIn checkIn = new CheckIn();
    checkIn.setReservationId(reservation.getId());
    checkIn.setRoomId(reservation.getRoomId());
    checkIn.setUserId(reservation.getUserId());
    checkIn.setActualCheckInDate(today);
    checkIn.setExpectedCheckOutDate(reservation.getCheckOutDate());
    checkIn.setIdType(checkInDTO.getIdType());
    checkIn.setIdNumber(checkInDTO.getIdNumber());
    checkIn.setAdditionalGuests(checkInDTO.getAdditionalGuests());
    checkIn.setSpecialRequests(checkInDTO.getSpecialRequests());
    checkIn.setStatus("CHECKED_IN");
    checkIn.setCreatedAt(LocalDateTime.now());
    
    // 更新房间状态
    Room room = roomRepository.findById(reservation.getRoomId()).orElse(null);
    if (room != null) {
        room.setStatus("OCCUPIED");
        room.setCurrentGuestId(reservation.getUserId());
        room.setLastCleanedDate(today);
        roomRepository.save(room);
    }
    
    // 更新预订状态
    reservation.setStatus("CHECKED_IN");
    reservation.setActualCheckInDate(today);
    reservationRepository.save(reservation);
    
    // 保存入住记录
    CheckIn savedCheckIn = checkInRepository.save(checkIn);
    
    // 记录账单信息
    Bill bill = new Bill();
    bill.setReservationId(reservation.getId());
    bill.setCheckInId(savedCheckIn.getId());
    bill.setUserId(reservation.getUserId());
    bill.setRoomCharge(reservation.getTotalPrice());
    bill.setStatus("PENDING");
    bill.setCreatedAt(LocalDateTime.now());
    billRepository.save(bill);
    
    // 发送欢迎信息
    User user = userRepository.findById(reservation.getUserId()).orElse(null);
    if (user != null && user.getPhone() != null) {
        smsService.sendWelcomeMessage(user.getPhone(), room.getRoomNumber());
    }
    
    Map<String, Object> response = new HashMap<>();
    response.put("checkIn", savedCheckIn);
    response.put("roomNumber", room != null ? room.getRoomNumber() : "未知");
    return ResponseEntity.ok(response);
} catch (Exception e) {
    logger.error("入住登记处理失败", e);
    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(Collections.singletonMap("message", "入住登记处理失败: " + e.getMessage()));
}

}

// 核心功能3: 退房结算处理 public ResponseEntity<Map<String, Object>> checkOut(@RequestBody CheckOutDTO checkOutDTO) { try { // 验证入住记录 CheckIn checkIn = checkInRepository.findById(checkOutDTO.getCheckInId()).orElse(null); if (checkIn == null) { return ResponseEntity.notFound().build(); }

    // 验证入住状态
    if (!"CHECKED_IN".equals(checkIn.getStatus())) {
        return ResponseEntity.badRequest().body(
            Collections.singletonMap("message", "该客房未处于入住状态，当前状态: " + checkIn.getStatus()));
    }
    
    // 获取预订和房间信息
    Reservation reservation = reservationRepository.findById(checkIn.getReservationId()).orElse(null);
    Room room = roomRepository.findById(checkIn.getRoomId()).orElse(null);
    
    if (reservation == null || room == null) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(Collections.singletonMap("message", "系统数据不一致，无法完成退房"));
    }
    
    // 计算实际住宿天数和费用
    LocalDate actualCheckOutDate = LocalDate.now();
    int actualStayDays = (int) ChronoUnit.DAYS.between(checkIn.getActualCheckInDate(), actualCheckOutDate);
    if (actualStayDays < 1) actualStayDays = 1; // 至少算一天
    
    BigDecimal roomRate = room.getPricePerNight();
    BigDecimal roomCharge = roomRate.multiply(new BigDecimal(actualStayDays));
    
    // 处理额外消费
    BigDecimal additionalCharges = BigDecimal.ZERO;
    if (checkOutDTO.getAdditionalCharges() != null && !checkOutDTO.getAdditionalCharges().isEmpty()) {
        for (AdditionalChargeDTO charge : checkOutDTO.getAdditionalCharges()) {
            additionalCharges = additionalCharges.add(charge.getAmount());
            
            // 记录额外消费明细
            AdditionalCharge additionalCharge = new AdditionalCharge();
            additionalCharge.setCheckInId(checkIn.getId());
            additionalCharge.setDescription(charge.getDescription());
            additionalCharge.setAmount(charge.getAmount());
            additionalCharge.setChargeDate(LocalDateTime.now());
            additionalChargeRepository.save(additionalCharge);
        }
    }
    
    // 计算总费用
    BigDecimal totalAmount = roomCharge.add(additionalCharges);
    
    // 检查是否有押金
    BigDecimal deposit = reservation.getDeposit() != null ? reservation.getDeposit() : BigDecimal.ZERO;
    
    // 计算需要支付的金额
    BigDecimal amountDue = totalAmount.subtract(deposit);
    
    // 创建退房记录
    CheckOut checkOut = new CheckOut();
    checkOut.setCheckInId(checkIn.getId());
    checkOut.setReservationId(reservation.getId());
    checkOut.setActualCheckOutDate(actualCheckOutDate);
    checkOut.setRoomCharge(roomCharge);
    checkOut.setAdditionalCharges(additionalCharges);
    checkOut.setTotalAmount(totalAmount);
    checkOut.setDeposit(deposit);
    checkOut.setAmountDue(amountDue);
    checkOut.setPaymentMethod(checkOutDTO.getPaymentMethod());
    checkOut.setPaymentStatus(amountDue.compareTo(BigDecimal.ZERO) <= 0 ? "PAID" : "PENDING");
    checkOut.setComments(checkOutDTO.getComments());
    checkOut.setCreatedAt(LocalDateTime.now());
    
    // 保存退房记录
    CheckOut savedCheckOut = checkOutRepository.save(checkOut);
    
    // 更新入住状态
    checkIn.setStatus("CHECKED_OUT");
    checkIn.setActualCheckOutDate(actualCheckOutDate);
    checkInRepository.save(checkIn);
    
    // 更新预订状态
    reservation.setStatus("COMPLETED");
    reservation.setActualCheckOutDate(actualCheckOutDate);
    reservationRepository.save(reservation);
    
    // 更新房间状态
    room.setStatus("DIRTY"); // 需要清洁
    room.setCurrentGuestId(null);
    roomRepository.save(room);
    
    // 安排房间清洁
    CleaningTask cleaningTask = new CleaningTask();
    cleaningTask.setRoomId(room.getId());
    cleaningTask.setStatus("PENDING");
    cleaningTask.setPriority("HIGH");
    cleaningTask.setScheduledDate(LocalDate.now());
    cleaningTask.setCreatedAt(LocalDateTime.now());
    cleaningTaskRepository.save(cleaningTask);
    
    // 更新账单状态
    Bill bill = billRepository.findByReservationId(reservation.getId());
    if (bill != null) {
        bill.setCheckOutId(savedCheckOut.getId());
        bill.setTotalAmount(totalAmount);
        bill.setPaymentMethod(checkOutDTO.getPaymentMethod());
        bill.setPaymentDate(LocalDateTime.now());
        bill.setStatus("PAID");
        billRepository.save(bill);
    }
    
    // 发送账单邮件
    User user = userRepository.findById(reservation.getUserId()).orElse(null);
    if (user != null && user.getEmail() != null) {
        emailService.sendCheckoutBill(user.getEmail(), savedCheckOut, room);
    }
    
    Map<String, Object> response = new HashMap<>();
    response.put("checkOut", savedCheckOut);
    response.put("roomNumber", room.getRoomNumber());
    response.put("stayDuration", actualStayDays + " 天");
    return ResponseEntity.ok(response);
} catch (Exception e) {
    logger.error("退房结算处理失败", e);
    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(Collections.singletonMap("message", "退房结算处理失败: " + e.getMessage()));
}

}

六、酒店推荐系统-文档展示

七、END

💕💕文末获取源码联系计算机编程果茶熊