家政管理系统开发档期预约模块Java实现:月嫂保姆排期冲突检测与日历管理

简介: 本文详解家政系统档期预约的Java实现:针对月嫂/保姆服务周期长、档期粒度粗、冲突检测复杂等特点,提出“区间重叠检测+两阶段预占确认+定时超时释放”方案,结合数据库唯一索引、`SELECT ... FOR UPDATE`行锁与缓存优化,保障高并发下的数据一致性与日历展示性能。

家政社区服务1.jpg 家政社区服务2.jpg 家政社区服务3.jpg

一、业务场景与技术难点

保姆、月嫂类家政服务的档期预约与普通到店预约有本质区别:服务周期长(月嫂通常26天或42天为一期,住家保姆按月续期)、档期锁定粒度粗(整段占用而非按小时)、冲突检测复杂(一个服务人员同一时间段只能服务一个家庭)。

在Java管理系统中实现档期预约功能,需要解决以下核心技术问题:

  • 时间段冲突检测:给定一个服务人员和目标时间段,快速判断该时段是否已被占用。
  • 档期预占与释放:用户下单后预占服务人员档期,支付确认后正式锁定,取消或超时后自动释放。
  • 档期日历展示:前端需要展示服务人员的档期日历(哪些日期已排满、哪些日期可预约),供用户选择。
  • 并发安全:多个用户同时预约同一服务人员时,必须保证不会出现"超卖"(同一档期被两个订单占用)。

二、整体设计方案

数据模型设计

档期预约涉及三张核心数据表:

  • 服务人员档期表(worker_schedule):记录每个服务人员的已占用时间段,字段包括worker_id、start_date、end_date、order_id、status(预占/已确认/已取消)。
  • 预约订单表(reservation_order):记录用户的预约请求,字段包括order_id、worker_id、user_id、service_type、start_date、end_date、status、created_at。
  • 档期日历缓存表(schedule_calendar):按服务人员维度缓存未来N天的档期状态,用于前端日历展示,定时刷新。

冲突检测策略

冲突检测采用区间重叠判断算法:两个时间段[start1, end1]和[start2, end2]重叠的充要条件是start1 <= end2 && start2 <= end1。

查询时通过数据库索引加速:对worker_schedule表的(worker_id, start_date, end_date)建立联合索引,查询条件为worker_id = ? AND start_date <= ? AND end_date >= ?,可高效命中重叠记录。

并发控制方案

为防止同一档期被多人抢占,采用数据库乐观锁 + 唯一约束双重保障:

  • 在worker_schedule表中对(worker_id, start_date, end_date)建立唯一索引,数据库层面杜绝重复插入。
  • 业务层使用SELECT ... FOR UPDATE行级锁,在事务内完成"查询冲突 → 插入占位"的原子操作。

档期日历生成逻辑

为前端提供日历数据时,按服务人员维度查询未来90天的档期状态,将已占用的时间段标记为"不可预约",剩余时间段标记为"可预约"。考虑到性能,日历数据通过定时任务每5分钟刷新一次缓存,而非每次实时查询。


三、核心代码实现

档期冲突检测与预约锁定服务

以下代码实现了档期冲突检测、预占锁定、确认/释放的完整业务逻辑,使用Spring事务和行级锁保证并发安全。

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.*;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Slf4j
@Service
public class ScheduleReservationService {

    @PersistenceContext
    private EntityManager em;

    @Data
    @Entity
    @Table(name = "worker_schedule",
           uniqueConstraints = @UniqueConstraint(
               columnNames = {"worker_id", "start_date", "end_date"}))
    public static class WorkerSchedule {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;

        @Column(name = "worker_id", nullable = false)
        private String workerId;

        @Column(name = "start_date", nullable = false)
        private LocalDate startDate;

        @Column(name = "end_date", nullable = false)
        private LocalDate endDate;

        @Column(name = "order_id")
        private String orderId;

        @Column(name = "status", nullable = false)
        @Enumerated(EnumType.STRING)
        private ScheduleStatus status;

        @Column(name = "created_at")
        private LocalDateTime createdAt;
    }

    public enum ScheduleStatus {
        PRE_OCCUPIED,   // 预占(下单未支付)
        CONFIRMED,      // 已确认(支付完成)
        CANCELLED,      // 已取消
        COMPLETED       // 服务已完成
    }

    /**
     * 检测指定服务人员在目标时间段内是否存在档期冲突
     */
    public boolean hasConflict(String workerId, LocalDate startDate, LocalDate endDate) {
        String jpql = "SELECT COUNT(s) FROM WorkerSchedule s " +
                      "WHERE s.workerId = :workerId " +
                      "AND s.status IN ('PRE_OCCUPIED', 'CONFIRMED') " +
                      "AND s.startDate <= :endDate " +
                      "AND s.endDate >= :startDate";

        Long count = em.createQuery(jpql, Long.class)
                .setParameter("workerId", workerId)
                .setParameter("startDate", startDate)
                .setParameter("endDate", endDate)
                .getSingleResult();

        return count > 0;
    }

    /**
     * 预占档期(用户下单时调用)
     * 使用悲观锁保证并发安全
     */
    @Transactional(rollbackFor = Exception.class)
    public WorkerSchedule preOccupySchedule(String workerId, LocalDate startDate,
                                             LocalDate endDate, String orderId) {
        // 行级锁查询,防止并发写入
        String lockJpql = "SELECT s FROM WorkerSchedule s " +
                          "WHERE s.workerId = :workerId " +
                          "AND s.startDate <= :endDate " +
                          "AND s.endDate >= :startDate " +
                          "AND s.status IN ('PRE_OCCUPIED', 'CONFIRMED') " +
                          "FOR UPDATE";

        List<WorkerSchedule> conflicts = em.createQuery(lockJpql, WorkerSchedule.class)
                .setParameter("workerId", workerId)
                .setParameter("startDate", startDate)
                .setParameter("endDate", endDate)
                .getResultList();

        if (!conflicts.isEmpty()) {
            throw new ScheduleConflictException(
                String.format("服务人员 %s 在 %s ~ %s 期间档期已被占用",
                              workerId, startDate, endDate));
        }

        // 无冲突,创建预占记录
        WorkerSchedule schedule = new WorkerSchedule();
        schedule.setWorkerId(workerId);
        schedule.setStartDate(startDate);
        schedule.setEndDate(endDate);
        schedule.setOrderId(orderId);
        schedule.setStatus(ScheduleStatus.PRE_OCCUPIED);
        schedule.setCreatedAt(LocalDateTime.now());

        em.persist(schedule);
        em.flush();

        log.info("档期预占成功: workerId={}, period={} ~ {}, orderId={}",
                 workerId, startDate, endDate, orderId);
        return schedule;
    }

    /**
     * 确认档期(用户支付完成后调用)
     */
    @Transactional(rollbackFor = Exception.class)
    public void confirmSchedule(String orderId) {
        String jpql = "UPDATE WorkerSchedule s SET s.status = 'CONFIRMED' " +
                      "WHERE s.orderId = :orderId AND s.status = 'PRE_OCCUPIED'";

        int updated = em.createQuery(jpql)
                .setParameter("orderId", orderId)
                .executeUpdate();

        if (updated == 0) {
            throw new ScheduleNotFoundException("未找到待确认的档期记录: " + orderId);
        }
        log.info("档期确认成功: orderId={}", orderId);
    }

    /**
     * 释放档期(用户取消订单或预占超时未支付时调用)
     */
    @Transactional(rollbackFor = Exception.class)
    public void releaseSchedule(String orderId) {
        String jpql = "UPDATE WorkerSchedule s SET s.status = 'CANCELLED' " +
                      "WHERE s.orderId = :orderId AND s.status = 'PRE_OCCUPIED'";

        int updated = em.createQuery(jpql)
                .setParameter("orderId", orderId)
                .executeUpdate();

        if (updated > 0) {
            log.info("档期释放成功: orderId={}", orderId);
        }
    }

    /**
     * 查询指定服务人员在指定月份的可预约日期
     */
    public List<LocalDate> getAvailableDates(String workerId, int year, int month) {
        LocalDate monthStart = LocalDate.of(year, month, 1);
        LocalDate monthEnd = monthStart.withDayOfMonth(monthStart.lengthOfMonth());

        String jpql = "SELECT s FROM WorkerSchedule s " +
                      "WHERE s.workerId = :workerId " +
                      "AND s.status IN ('PRE_OCCUPIED', 'CONFIRMED') " +
                      "AND s.startDate <= :monthEnd " +
                      "AND s.endDate >= :monthStart";

        List<WorkerSchedule> occupied = em.createQuery(jpql, WorkerSchedule.class)
                .setParameter("workerId", workerId)
                .setParameter("monthStart", monthStart)
                .setParameter("monthEnd", monthEnd)
                .getResultList();

        // 生成当月所有日期,排除已被占用的
        List<LocalDate> allDates = new java.util.ArrayList<>();
        for (LocalDate d = monthStart; !d.isAfter(monthEnd); d = d.plusDays(1)) {
            allDates.add(d);
        }

        return allDates.stream().filter(date ->
            occupied.stream().noneMatch(s ->
                !date.isBefore(s.getStartDate()) && !date.isAfter(s.getEndDate())
            )
        ).collect(java.util.stream.Collectors.toList());
    }
}

预占超时自动释放定时任务

以下代码实现了预占档期的超时自动释放机制,防止用户下单未支付导致档期被长期占用。

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.time.LocalDateTime;
import java.util.List;

@Slf4j
@Component
public class ScheduleTimeoutHandler {

    @PersistenceContext
    private EntityManager em;

    // 预占超时阈值:30分钟未支付则自动释放
    private static final int PRE_OCCUPY_TIMEOUT_MINUTES = 30;

    /**
     * 每5分钟执行一次,扫描并释放超时的预占档期
     */
    @Scheduled(fixedRate = 5 * 60 * 1000)
    @Transactional(rollbackFor = Exception.class)
    public void releaseExpiredPreOccupations() {
        LocalDateTime threshold = LocalDateTime.now()
                .minusMinutes(PRE_OCCUPY_TIMEOUT_MINUTES);

        String jpql = "SELECT s FROM WorkerSchedule s " +
                      "WHERE s.status = 'PRE_OCCUPIED' " +
                      "AND s.createdAt < :threshold";

        List<ScheduleReservationService.WorkerSchedule> expired =
                em.createQuery(jpql, ScheduleReservationService.WorkerSchedule.class)
                  .setParameter("threshold", threshold)
                  .getResultList();

        if (expired.isEmpty()) {
            return;
        }

        for (ScheduleReservationService.WorkerSchedule schedule : expired) {
            schedule.setStatus(ScheduleReservationService.ScheduleStatus.CANCELLED);
            em.merge(schedule);

            log.warn("预占档期超时自动释放: workerId={}, orderId={}, " +
                     "period={} ~ {}, occupiedSince={}",
                     schedule.getWorkerId(),
                     schedule.getOrderId(),
                     schedule.getStartDate(),
                     schedule.getEndDate(),
                     schedule.getCreatedAt());
        }

        em.flush();
        log.info("本次共释放 {} 条超时预占档期记录", expired.size());
    }

    /**
     * 每天凌晨执行,将已过期的已确认档期标记为已完成
     * (服务结束日期已过的记录自动归档)
     */
    @Scheduled(cron = "0 0 2 * * ?")
    @Transactional(rollbackFor = Exception.class)
    public void archiveCompletedSchedules() {
        LocalDateTime now = LocalDateTime.now();

        String jpql = "UPDATE WorkerSchedule s SET s.status = 'COMPLETED' " +
                      "WHERE s.status = 'CONFIRMED' " +
                      "AND s.endDate < CURRENT_DATE";

        int updated = em.createQuery(jpql).executeUpdate();
        if (updated > 0) {
            log.info("归档 {} 条已完成的服务档期记录", updated);
        }
    }
}

四、关键设计要点

关于预占与确认的两阶段设计:用户下单时仅预占档期(状态为PRE_OCCUPIED),支付成功后才正式确认(状态变为CONFIRMED)。这种设计避免了用户下单未支付导致档期被无效锁定的问题。预占记录设置超时时间(如30分钟),超时未支付的由定时任务自动释放。

关于并发安全的选型:上述代码采用SELECT ... FOR UPDATE悲观锁方案,适合家政预约这种并发量不高的场景(同一服务人员同一时段被多人同时抢的概率较低)。如果业务量增大,可以改为乐观锁方案(在worker_schedule表中增加version字段,更新时校验版本号),减少锁等待。

关于档期日历的性能优化:getAvailableDates方法每次实时查询数据库,在数据量较大时可能影响响应速度。生产环境中建议引入Redis缓存,按worker_id + 年月为key缓存日历数据,TTL设为5分钟。服务人员档期发生变更时主动失效对应缓存。

关于服务周期的灵活性:月嫂服务通常以26天或42天为一期,住家保姆按月续期,白班保姆可能按天计。上述代码中start_date和end_date为灵活的日期区间,不硬编码服务周期长度,由前端根据服务类型传入具体日期,后端只做冲突检测,这样新增服务类型时无需修改档期模块代码。

关于数据清理策略:随着业务运行,worker_schedule表中会积累大量历史数据。建议按季度归档,将已完成(COMPLETED)且结束日期超过6个月的记录迁移到历史表,保持主表数据量可控,确保查询性能稳定。


以上是家政管理系统档期预约模块的Java实现方案。核心思路是"区间重叠冲突检测 + 两阶段预占确认 + 定时超时释放",通过数据库唯一约束和行级锁保证并发安全,通过定时任务实现档期的自动生命周期管理,适合作为保姆月嫂类家政系统预约功能的开发参考。

相关文章
|
18天前
|
Linux 开发工具 iOS开发
Codex保姆级教程(下载+安装+登录+使用,含所有版本,2026最新)
Codex是OpenAI推出的开源AI编程智能体,本地运行,可理解整个代码库,支持自然语言指令改代码、执行命令、跑测试、修Bug,兼容Win/macOS/Linux。(239字)
7731 57
|
3天前
|
弹性计算 人工智能 API
Codex超详细入门指南(下载·安装·登录·上手,全版本覆盖,2026最新版)
建议收藏本教程,2026 全年各版本更新随时回来查阅。如果你在搭建过程中遇到任何问题,欢迎结合 阿里云工单系统 提交技术支持请求,或在 阿里云开发者社区 搜索 Codex 相关话题交流。 祝你编码愉快,效率翻倍!
1454 0
|
5天前
|
JSON 前端开发 API
阿里云最新Qwen4-Max大模型介绍:模型定位、特征、能力、适用场景解析
2026 年 11 月 11 日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问 AI 平台 Token Plan,并同步接入千问办公、Qoder 等入口。该版本聚焦知识理解、世界感知、编程与 Agentic 四项升级,主打复杂编程、专业办公、前端设计与专业软件操作。预览期至 11 月 25 日 24:00,到期后模型标识下线;限时 2 折、新用户再享 5 折,最低 1 折可体验。
|
18天前
|
JavaScript API iOS开发
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(DSH)是DeepSeek于2026年开源的MIT协议AI Agent框架,支持插件化组装模型、工具、沙箱与UI,兼容主流大模型。本文提供免Node.js的桌面端安装包(Win/macOS),含详细图文教程及热门插件推荐。
5677 68
|
6天前
|
云安全 人工智能 安全
|
13天前
|
Linux 开发工具 iOS开发
2026最新codex下载安装保姆级使用教程(下载+安装+登录+使用,含所有历史版本)
本文详解OpenAI Codex国内快速上手指南:提供Win/macOS/Linux全平台免安装包、npm/Homebrew等多方式安装、账号/API Key双登录、简体中文切换,覆盖下载、安装、汉化、使用及高频避坑(如微软商店失败、npm超时等),10分钟即可跑通。
2907 9
|
5天前
|
人工智能 前端开发 API
阿里云Qwen4-Max 大模型详解:定位、特征、能力、适用场景与相对Qwen3-Max差异解析
2026年11月11日,阿里发布第四代旗舰模型Qwen4-Max预览版,首发千问AI平台Token Plan并接入千问办公、Qoder等入口。该版本聚焦知识理解、世界感知、编程与Agentic四项升级,主打复杂编程、专业办公、前端设计与专业软件操作等真实任务。预览期为11月11日10:00至11月25日24:00,仅支持Token Plan调用,到期后模型标识下线;限时2折、新用户再享5折,最低1折可体验。
|
3天前
|
Linux Go 开发工具
手机上跑 DeepSeek 智能体:开源安卓客户端 DSH Go 安装与使用指南
DSH Go 是一款开源安卓客户端,将 DeepSeek Harness 智能体引擎装进手机:免 Root、免 Termux,一键安装即用;支持本机运行(内置 Ubuntu+Node.js)或远程接管电脑会话;具备插话打断、过程折叠、屏幕操控、端到端加密分享等特色功能,真正实现智能体“口袋化”。
1906 0
|
10天前
|
人工智能 安全 API
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(dsh)是DeepSeek AI于2026年开源的轻量级Agent运行框架,基于Cordis内核,践行“一切皆插件”理念。支持Web/桌面双端,开箱即用;内置多模型接入、丰富插件生态(超3.5万),适配编程、办公、创作等场景。(239字)
1869 1