家政上门预约系统开发实战:服务人员档期管理与自动排单算法设计

简介: 本文详解家政上门预约系统档期管理:聚焦时间资源特性,涵盖数据模型设计、多维度冲突检测(含缓冲时间)、客户指定/平台自动派单算法(加权评分+负载均衡),并提供Java核心代码实现及并发安全、预锁定等优化建议。

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

一、前言

在保姆、月嫂等上门家政服务场景中,档期管理是系统设计的核心难点之一。与电商库存不同,服务人员的"库存"本质上是时间资源——每位服务人员每天可服务的时间有限,且不同订单的服务时长、服务类型各不相同。如何高效地进行档期冲突检测、自动匹配空闲时段、智能排单调度,直接决定了平台的运营效率和客户满意度。

本文围绕家政上门预约系统的档期管理模块,讲解数据模型设计、冲突检测机制以及自动排单算法的实现思路。


二、档期管理的业务特点

2.1 家政服务档期的特殊性

家政服务的档期管理与普通预约系统存在显著差异:

  • 服务时长差异大:钟点保洁可能只需2-3小时,月嫂服务则按26天或42天为一个周期,住家保姆甚至按月续约。不同服务类型的档期粒度完全不同。
  • 连续性约束:月嫂、住家保姆等长期服务一旦排定,整个服务周期内该服务人员不可再接其他订单。
  • 缓冲时间:服务人员从上一个订单结束到下一个订单开始之间,可能需要预留通勤或休息时间。
  • 多区域服务:部分服务人员可在多个区域接单,档期需与区域调度联动。

2.2 档期的三种状态

服务人员的每一段时间可以处于以下三种状态之一:

  • 空闲(Available):未被任何订单占用,可接受新预约
  • 已锁定(Locked):已被订单占用,不可再预约
  • 不可用(Unavailable):服务人员主动设置的休息时间(如请假、培训等)

三、数据模型设计

3.1 服务人员档期表(staff_availability)

用于记录服务人员的基础可工作时间段。核心字段包括:记录ID、服务人员ID、日期、可服务开始时间、可服务结束时间、状态(空闲/不可用)、备注。

这张表相当于服务人员的"日历模板",定义了每天的工作时间窗口。例如某月嫂设置每天 08:00-20:00 为可服务时间,周末休息。

3.2 订单排期表(order_schedule)

用于记录已确认订单对服务人员时间的占用。核心字段包括:排期ID、订单ID、服务人员ID、服务开始时间、服务结束时间、排期类型(预约锁定/实际服务中)、状态。

3.3 排期冲突检测的核心逻辑

判断两个时间段是否冲突的经典条件为:新订单开始时间 < 已有排期结束时间 且 新订单结束时间 > 已有排期开始时间。在此基础上,还需加入缓冲时间的考量。


四、自动排单的业务流程

4.1 客户指定服务人员模式

客户在下单时直接选择某位服务人员,系统需要完成以下步骤:

  1. 查询该服务人员在客户期望时间段内是否存在排期冲突
  2. 若存在冲突,返回冲突提示及该服务人员最近的可用时间段建议
  3. 若无冲突,锁定档期并创建订单

4.2 平台自动派单模式

客户仅选择服务类型和期望时间,由系统自动匹配最合适的服务人员。派单算法需要考虑以下维度:

  • 档期匹配:服务人员在该时间段是否空闲
  • 区域匹配:服务人员的服务区域是否覆盖客户地址
  • 技能匹配:服务人员的技能标签是否满足客户需求
  • 评分优先:在满足以上条件的人员中,优先推荐评分更高的
  • 负载均衡:避免部分服务人员订单过于集中,其他人员长期空闲

4.3 排单冲突的兜底策略

当客户期望时间段所有匹配的服务人员都已被占用时,系统应提供以下兜底方案:

  • 推荐相邻时间段(前后浮动1-2小时)的可用服务人员
  • 推荐同区域其他服务人员的空闲档期
  • 支持客户提交"候补预约",当有订单取消时自动通知候补客户

五、核心代码实现

档期冲突检测与可用时段查询

以下代码实现了服务人员档期的冲突检测,以及在冲突时自动查找最近可用时段的功能:

@Service
public class ScheduleServiceImpl implements ScheduleService {

    @Autowired
    private OrderScheduleMapper scheduleMapper;

    @Autowired
    private StaffAvailabilityMapper availabilityMapper;

    // 缓冲时间(分钟),服务人员两次订单之间最少间隔
    private static final int BUFFER_MINUTES = 30;

    /**
     * 检测指定服务人员在给定时间段是否存在排期冲突
     */
    public Result<ScheduleCheckVO> checkConflict(Long staffId, LocalDateTime startTime, LocalDateTime endTime) {
        if (staffId == null || startTime == null || endTime == null) {
            return Result.fail("参数不能为空");
        }
        if (!endTime.isAfter(startTime)) {
            return Result.fail("结束时间必须晚于开始时间");
        }

        // 1. 查询该服务人员在此时间段内是否有已锁定的排期
        LambdaQueryWrapper<OrderSchedule> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(OrderSchedule::getStaffId, staffId)
               .eq(OrderSchedule::getStatus, 1)
               .lt(OrderSchedule::getStartTime, endTime.plusMinutes(BUFFER_MINUTES))
               .gt(OrderSchedule::getEndTime, startTime.minusMinutes(BUFFER_MINUTES));

        List<OrderSchedule> conflicts = scheduleMapper.selectList(wrapper);

        ScheduleCheckVO vo = new ScheduleCheckVO();
        vo.setStaffId(staffId);
        vo.setRequestedStart(startTime);
        vo.setRequestedEnd(endTime);

        if (!conflicts.isEmpty()) {
            vo.setHasConflict(true);
            vo.setConflictDetails(conflicts.stream().map(c -> {
                ScheduleCheckVO.ConflictItem item = new ScheduleCheckVO.ConflictItem();
                item.setOrderId(c.getOrderId());
                item.setStartTime(c.getStartTime());
                item.setEndTime(c.getEndTime());
                return item;
            }).collect(Collectors.toList()));

            // 2. 冲突时,查找最近的可用时段
            List<TimeSlotVO> availableSlots = findNearestAvailableSlots(staffId, startTime, endTime, 3);
            vo.setSuggestedSlots(availableSlots);
        } else {
            vo.setHasConflict(false);
        }

        return Result.success(vo);
    }

    /**
     * 查找指定服务人员最近的N个可用时间段
     */
    public List<TimeSlotVO> findNearestAvailableSlots(Long staffId, LocalDateTime desiredStart, 
                                                       LocalDateTime desiredEnd, int limit) {
        // 查询服务人员的基础可工作时间
        LambdaQueryWrapper<StaffAvailability> availWrapper = new LambdaQueryWrapper<>();
        availWrapper.eq(StaffAvailability::getStaffId, staffId)
                    .eq(StaffAvailability::getStatus, 1)
                    .ge(StaffAvailability::getDate, desiredStart.toLocalDate())
                    .le(StaffAvailability::getDate, desiredStart.toLocalDate().plusDays(7));
        List<StaffAvailability> availabilities = availabilityMapper.selectList(availWrapper);

        // 查询已占用的时间段
        LambdaQueryWrapper<OrderSchedule> occupiedWrapper = new LambdaQueryWrapper<>();
        occupiedWrapper.eq(OrderSchedule::getStaffId, staffId)
                       .eq(OrderSchedule::getStatus, 1)
                       .ge(OrderSchedule::getStartTime, desiredStart.toLocalDate().atStartOfDay())
                       .le(OrderSchedule::getEndTime, desiredStart.toLocalDate().plusDays(7).atTime(23, 59, 59));
        List<OrderSchedule> occupiedSlots = scheduleMapper.selectList(occupiedWrapper);

        long requiredDuration = java.time.Duration.between(desiredStart, desiredEnd).toMinutes();

        List<TimeSlotVO> availableSlots = new ArrayList<>();
        for (StaffAvailability avail : availabilities) {
            LocalDateTime dayStart = avail.getDate().atTime(avail.getAvailableStart());
            LocalDateTime dayEnd = avail.getDate().atTime(avail.getAvailableEnd());

            // 找出当天已占用时间段之间的空闲间隙
            List<LocalDateTime[]> gaps = findGaps(dayStart, dayEnd, occupiedSlots, requiredDuration);
            for (LocalDateTime[] gap : gaps) {
                TimeSlotVO slot = new TimeSlotVO();
                slot.setStartTime(gap[0]);
                slot.setEndTime(gap[1]);
                availableSlots.add(slot);
            }
        }

        // 按与期望开始时间的距离排序,取最近的N个
        availableSlots.sort(Comparator.comparingLong(slot -> 
            Math.abs(java.time.Duration.between(desiredStart, slot.getStartTime()).toMinutes())));

        return availableSlots.stream().limit(limit).collect(Collectors.toList());
    }

    private List<LocalDateTime[]> findGaps(LocalDateTime dayStart, LocalDateTime dayEnd, 
                                            List<OrderSchedule> occupied, long requiredDuration) {
        List<LocalDateTime[]> gaps = new ArrayList<>();
        List<OrderSchedule> dayOccupied = occupied.stream()
            .filter(o -> o.getStartTime().isBefore(dayEnd) && o.getEndTime().isAfter(dayStart))
            .sorted(Comparator.comparing(OrderSchedule::getStartTime))
            .collect(Collectors.toList());

        LocalDateTime cursor = dayStart;
        for (OrderSchedule occ : dayOccupied) {
            LocalDateTime gapEnd = occ.getStartTime().minusMinutes(BUFFER_MINUTES);
            if (java.time.Duration.between(cursor, gapEnd).toMinutes() >= requiredDuration) {
                gaps.add(new LocalDateTime[]{cursor, gapEnd});
            }
            cursor = occ.getEndTime().plusMinutes(BUFFER_MINUTES);
        }
        if (java.time.Duration.between(cursor, dayEnd).toMinutes() >= requiredDuration) {
            gaps.add(new LocalDateTime[]{cursor, dayEnd});
        }
        return gaps;
    }
}

自动派单匹配算法

以下代码实现了平台自动派单的核心逻辑,综合考虑档期空闲、区域覆盖、评分和负载均衡四个维度进行加权打分排序:

@Service
public class AutoDispatchServiceImpl implements AutoDispatchService {

    @Autowired
    private StaffMapper staffMapper;

    @Autowired
    private ScheduleService scheduleService;

    @Autowired
    private StaffScheduleMapper scheduleMapper;

    // 各维度权重配置
    private static final double WEIGHT_SCHEDULE = 0.4;
    private static final double WEIGHT_AREA = 0.25;
    private static final double WEIGHT_RATING = 0.25;
    private static final double WEIGHT_LOAD = 0.1;

    public Result<DispatchResultVO> autoDispatch(DispatchRequestDTO dto) {
        // 1. 查询所有状态正常的服务人员
        LambdaQueryWrapper<Staff> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Staff::getStatus, 1)
               .eq(dto.getServiceType() != null, Staff::getServiceType, dto.getServiceType());
        List<Staff> allStaff = staffMapper.selectList(wrapper);

        if (allStaff.isEmpty()) {
            return Result.fail("暂无可用的服务人员");
        }

        // 2. 过滤:档期空闲的服务人员
        List<Staff> availableStaff = allStaff.stream()
            .filter(staff -> {
                Result<ScheduleCheckVO> checkResult = scheduleService.checkConflict(
                    staff.getId(), dto.getStartTime(), dto.getEndTime());
                return checkResult.isSuccess() && !checkResult.getData().getHasConflict();
            })
            .collect(Collectors.toList());

        if (availableStaff.isEmpty()) {
            return Result.fail("所选时间段暂无空闲服务人员,请尝试调整时间");
        }

        // 3. 多维度打分排序
        List<StaffScoreVO> scoredStaff = availableStaff.stream().map(staff -> {
            StaffScoreVO scoreVO = new StaffScoreVO();
            scoreVO.setStaffId(staff.getId());
            scoreVO.setStaffName(staff.getName());

            // 档期维度:空闲即满分
            double scheduleScore = 100;

            // 区域维度:精确匹配区域得满分,相邻区域得60分
            double areaScore = (staff.getServiceAreas() != null 
                && staff.getServiceAreas().contains(dto.getDistrictCode())) ? 100 : 60;

            // 评分维度:直接取服务人员评分(0-100)
            double ratingScore = staff.getRating() != null ? staff.getRating().doubleValue() : 50;

            // 负载均衡维度:近期订单越少得分越高
            double loadScore = calculateLoadScore(staff.getId());

            double totalScore = scheduleScore * WEIGHT_SCHEDULE 
                              + areaScore * WEIGHT_AREA 
                              + ratingScore * WEIGHT_RATING 
                              + loadScore * WEIGHT_LOAD;

            scoreVO.setScheduleScore(scheduleScore);
            scoreVO.setAreaScore(areaScore);
            scoreVO.setRatingScore(ratingScore);
            scoreVO.setLoadScore(loadScore);
            scoreVO.setTotalScore(totalScore);
            return scoreVO;
        }).sorted(Comparator.comparingDouble(StaffScoreVO::getTotalScore).reversed())
          .collect(Collectors.toList());

        // 4. 返回推荐结果(取前5名)
        DispatchResultVO result = new DispatchResultVO();
        result.setCandidates(scoredStaff.stream().limit(5).collect(Collectors.toList()));
        result.setBestMatch(scoredStaff.get(0));

        return Result.success(result);
    }

    private double calculateLoadScore(Long staffId) {
        // 查询近7天的订单数量
        LambdaQueryWrapper<OrderSchedule> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(OrderSchedule::getStaffId, staffId)
               .eq(OrderSchedule::getStatus, 1)
               .ge(OrderSchedule::getStartTime, LocalDateTime.now().minusDays(7))
               .le(OrderSchedule::getStartTime, LocalDateTime.now());
        Long recentOrders = scheduleMapper.selectCount(wrapper);

        // 订单越少得分越高,假设7天内5单为满负荷
        double maxLoad = 5.0;
        double score = Math.max(0, (maxLoad - recentOrders) / maxLoad * 100);
        return score;
    }
}

六、设计要点与优化建议

并发安全:当多个客户同时预约同一服务人员的同一时间段时,需要在数据库层面通过唯一索引或乐观锁防止重复锁定。建议在排期表上对 (staff_id, start_time, end_time) 建立唯一索引作为最终兜底。

缓冲时间配置化:不同服务类型的缓冲时间可能不同。例如月嫂连续服务之间可能需要1-2天的交接期,而钟点保洁只需30分钟通勤缓冲。建议将缓冲时间作为服务类型的配置项,而非硬编码常量。

档期预锁定机制:客户提交预约后、支付完成前,建议先对档期进行"预锁定"(设置较短的过期时间,如15分钟)。支付成功后转为正式锁定,超时未支付则自动释放。这样可以避免客户在支付过程中档期被他人抢走。

排单算法的可扩展性:自动派单的打分权重建议做成可配置项,运营人员可以根据实际业务情况调整各维度的权重比例,而无需修改代码。


七、总结

家政上门预约系统的档期管理,核心在于时间段的冲突检测和智能排单匹配。冲突检测需要精确处理时间区间的重叠判断,并考虑缓冲时间的约束;自动排单则需要综合档期、区域、评分、负载均衡等多维度进行加权决策。在实际项目中,还需要结合并发控制、预锁定机制、超时释放等手段保证系统的可靠性和数据一致性。

相关文章
|
18天前
|
Linux 开发工具 iOS开发
Codex保姆级教程(下载+安装+登录+使用,含所有版本,2026最新)
Codex是OpenAI推出的开源AI编程智能体,本地运行,可理解整个代码库,支持自然语言指令改代码、执行命令、跑测试、修Bug,兼容Win/macOS/Linux。(239字)
7768 58
|
3天前
|
弹性计算 人工智能 API
Codex超详细入门指南(下载·安装·登录·上手,全版本覆盖,2026最新版)
建议收藏本教程,2026 全年各版本更新随时回来查阅。如果你在搭建过程中遇到任何问题,欢迎结合 阿里云工单系统 提交技术支持请求,或在 阿里云开发者社区 搜索 Codex 相关话题交流。 祝你编码愉快,效率翻倍!
1459 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),含详细图文教程及热门插件推荐。
5682 68
|
6天前
|
云安全 人工智能 安全
|
13天前
|
Linux 开发工具 iOS开发
2026最新codex下载安装保姆级使用教程(下载+安装+登录+使用,含所有历史版本)
本文详解OpenAI Codex国内快速上手指南:提供Win/macOS/Linux全平台免安装包、npm/Homebrew等多方式安装、账号/API Key双登录、简体中文切换,覆盖下载、安装、汉化、使用及高频避坑(如微软商店失败、npm超时等),10分钟即可跑通。
2912 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)或远程接管电脑会话;具备插话打断、过程折叠、屏幕操控、端到端加密分享等特色功能,真正实现智能体“口袋化”。
1967 0
|
10天前
|
人工智能 安全 API
DeepSeek Harness下载、安装、配置一篇搞定(2026整理,送常用插件)
DeepSeek Harness(dsh)是DeepSeek AI于2026年开源的轻量级Agent运行框架,基于Cordis内核,践行“一切皆插件”理念。支持Web/桌面双端,开箱即用;内置多模型接入、丰富插件生态(超3.5万),适配编程、办公、创作等场景。(239字)
1869 1