day08-智能调度之运输任务

shuhongfan
1 parent 2266e9a9
Showing 4 changed files with 505 additions and 5 deletions
sl-express-ms-dispatch-service/src/main/java/com/sl/ms/dispatch/job/DispatchJob.java
sl-express-ms-work-service/src/main/java/com/sl/ms/work/entity/TransportTaskEntity.java
sl-express-ms-work-service/src/main/java/com/sl/ms/work/mq/TransportTaskMQListener.java
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/impl/TransportOrderServiceImpl.java
 package com.sl.ms.dispatch.job;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.NumberUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
+import com.sl.ms.base.api.common.MQFeign;
+import com.sl.ms.base.api.truck.TruckPlanFeign;
+import com.sl.ms.base.domain.truck.TruckDto;
+import com.sl.ms.base.domain.truck.TruckPlanDto;
+import com.sl.ms.dispatch.dto.DispatchMsgDTO;
+import com.sl.ms.dispatch.mq.TransportOrderDispatchMQListener;
+import com.sl.transport.common.constant.Constants;
 import com.xxl.job.core.context.XxlJobHelper;
 import com.xxl.job.core.handler.annotation.XxlJob;
 import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Component;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
 /**
  * 调度运输任务
  */
@@ -12,6 +36,28 @@ import org.springframework.stereotype.Component;
 @Slf4j
 public class DispatchJob {
+    @Autowired
+    private TransportOrderDispatchMQListener transportOrderDispatchMQListener;
+
+    @Autowired
+    private StringRedisTemplate stringRedisTemplate;
+
+    @Autowired
+    private RedissonClient redissonClient;
+
+    @Autowired
+    private TruckPlanFeign truckPlanFeign;
+
+    @Autowired
+    private MQFeign mqFeign;
+
+    @Value("${sl.volume.ratio:0.95}")
+    private Double volumeRatio;
+
+    @Value("${sl.weight.ratio:0.95}")
+    private Double weightRatio;
+
+
     /**
      * 分片广播方式处理运单，生成运输任务
      */
@@ -21,6 +67,166 @@ public class DispatchJob {
         int shardIndex = XxlJobHelper.getShardIndex();
         int shardTotal = XxlJobHelper.getShardTotal();
-        //TODO 待实现
+//        根据分片参数 2小时内并且可用状态车辆
+        List<TruckPlanDto> truckPlanDtoList = truckPlanFeign.pullUnassignedPlan(shardTotal, shardIndex);
+        if (CollUtil.isEmpty(truckPlanDtoList)) {
+            return;
+        }
+
+//        对每一个车辆都进行处理
+//        为了相同目的地的运单尽可能的分配在一个运输任务中，所有需要在读取数据时进行锁定
+//        一辆车处理完成后再开始下一个车辆处理
+//        在这里，使用redis的分布式锁实现
+        for (TruckPlanDto truckPlanDto : truckPlanDtoList) {
+//            校验车辆计划对象
+            if (ObjectUtil.hasEmpty(truckPlanDto.getStartOrganId(), truckPlanDto.getEndOrganId(),
+                    truckPlanDto.getTransportTripsId(), truckPlanDto.getId())) {
+                log.error("车辆计划对象数据不符合要求，truckPlanDto->{}", truckPlanDto);
+                continue;
+            }
+
+//            根据该车辆的开始、结束结构ID，来确定要处理的运单数据集合
+            Long startOrganId = truckPlanDto.getStartOrganId();
+            Long endOrganId = truckPlanDto.getEndOrganId();
+            String redisKey = transportOrderDispatchMQListener.getListRedisKey(startOrganId, endOrganId);
+            String lockRedisKey = Constants.LOCKS.DISPATCH_LOCK_PREFIX + redisKey;
+
+//            获取锁
+            RLock lock = redissonClient.getFairLock(lockRedisKey);
+            ArrayList<DispatchMsgDTO> dispatchMsgDTOList = new ArrayList<>();
+            try {
+//                锁定，一直等等锁，一定要获取到锁，因为查询到车辆的调度状态设置为：已分配
+                lock.lock();
+//                计算车辆运力、合并运单
+                executeTransportTask(redisKey, truckPlanDto.getTruckDto(), dispatchMsgDTOList);
+            } finally {
+                lock.unlock();
+            }
+            createTransportTask(truckPlanDto, startOrganId, endOrganId, dispatchMsgDTOList);
+        }
+        //发送消息通过车辆已经完成调度
+        completeTruckPlan(truckPlanDtoList);
     }
-}
+
+    /**
+     * 运单处理
+     *
+     * @param redisKey
+     * @param truckDto
+     * @param dispatchMsgDTOList
+     */
+    private void executeTransportTask(String redisKey, TruckDto truckDto, List<DispatchMsgDTO> dispatchMsgDTOList) {
+        String redisData = stringRedisTemplate.opsForList().rightPop(redisKey);
+        if (StrUtil.isEmptyIfStr(redisData)) {
+//            车辆没有运单需要运输
+            return;
+        }
+
+        DispatchMsgDTO dispatchMsgDTO = JSONUtil.toBean(redisData, DispatchMsgDTO.class);
+
+//        计算该车辆已经分配的运单，是否超出其能力，载重或体积超出，需要将新拿到的运单加进去后进行比较
+        BigDecimal totalWeight = NumberUtil.add(NumberUtil.toBigDecimal(
+                dispatchMsgDTOList
+                        .stream()
+                        .mapToDouble(DispatchMsgDTO::getTotalWeight)
+                        .sum()
+        ), dispatchMsgDTO.getTotalWeight());
+
+        BigDecimal totalVolume = NumberUtil.add(NumberUtil.toBigDecimal(dispatchMsgDTOList
+                        .stream()
+                        .mapToDouble(DispatchMsgDTO::getTotalVolume)
+                        .sum()),
+                dispatchMsgDTO.getTotalVolume());
+
+//        车辆最大的容积和载重要留有余量，否则可能会超重或装不下
+        BigDecimal maxAllowAbleLoad = NumberUtil.mul(truckDto.getAllowableLoad(), weightRatio);
+        BigDecimal maxAllowAbleVolume = NumberUtil.mul(truckDto.getAllowableVolume(), volumeRatio);
+
+        if (NumberUtil.isGreaterOrEqual(totalVolume, maxAllowAbleVolume) ||
+                NumberUtil.isGreaterOrEqual(totalWeight, maxAllowAbleLoad)) {
+//            超出车辆运力，需要取货的运单再放回去，放到最右边，以便保证运单处理的顺序
+            stringRedisTemplate.opsForList().rightPush(redisKey, redisData);
+            return;
+        }
+
+//        没有超出运力，讲该运单加入到集合中
+        dispatchMsgDTOList.add(dispatchMsgDTO);
+
+//        递归处理运单
+        executeTransportTask(redisKey, truckDto, dispatchMsgDTOList);
+    }
+
+    /**
+     * 消息通知生成运输任务
+     *
+     * @param truckPlanDto
+     * @param startOrganId
+     * @param endOrganId
+     * @param dispatchMsgDTOList
+     */
+    private void createTransportTask(TruckPlanDto truckPlanDto, Long startOrganId, Long endOrganId, List<DispatchMsgDTO> dispatchMsgDTOList) {
+        //将运单合并的结果以消息的方式发送出去
+        //key-> 车辆id，value ->  运单id列表
+        //{"driverId":123, "truckPlanId":456, "truckId":1210114964812075008,"totalVolume":4.2,"endOrganId":90001,"totalWeight":7,"transportOrderIdList":[320733749248,420733749248],"startOrganId":100280}
+        List<String> transportOrderIdList = CollUtil.getFieldValues(dispatchMsgDTOList, "transportOrderIdList", String.class);
+
+//        司机列表确保不为null
+        List<Long> driverIds = CollUtil.isNotEmpty(truckPlanDto.getDriverIds()) ? truckPlanDto.getDriverIds() : ListUtil.empty();
+
+        Map<Object, Object> msgResult = MapUtil.builder()
+                .put("truckId", truckPlanDto.getTruckId()) //车辆id
+                .put("driverIds", driverIds) //司机id
+                .put("truckPlanId", truckPlanDto.getId()) //车辆计划id
+                .put("transportTripsId", truckPlanDto.getTransportTripsId()) //车次id
+                .put("startOrganId", startOrganId) //开始机构id
+                .put("endOrganId", endOrganId) //结束机构id
+//              运单id列表
+                .put("transportOrderIdList", transportOrderIdList)
+//                总重量
+                .put("totalWeight",
+                        dispatchMsgDTOList.stream()
+                                .mapToDouble(DispatchMsgDTO::getTotalWeight)
+                                .sum()
+                )
+//                总体积
+                .put("totalVolume",
+                        dispatchMsgDTOList.stream()
+                                .mapToDouble(DispatchMsgDTO::getTotalVolume)
+                                .sum())
+                .build();
+
+//        发送消息
+        String jsonMsg = JSONUtil.toJsonStr(msgResult);
+        mqFeign.sendMsg(Constants.MQ.Exchanges.TRANSPORT_TASK,
+                Constants.MQ.RoutingKeys.TRANSPORT_TASK_CREATE,
+                jsonMsg);
+
+        if (CollUtil.isNotEmpty(transportOrderIdList)) {
+//            删除redis中set存储的运单数据
+            String setRedisKey = transportOrderDispatchMQListener.getSetRedisKey(startOrganId, endOrganId);
+            stringRedisTemplate.opsForSet().remove(setRedisKey, transportOrderIdList.toArray());
+        }
+
+    }
+
+    /**
+     * 消息通知完成车辆计划
+     * private void completeTruckPlan(List<TruckPlanDto> truckDtoList) {
+     * @param truckDtoList
+     */
+    private void completeTruckPlan(List<TruckPlanDto> truckDtoList) {
+        //{"ids":[1,2,3], "created":123456}
+        Map<Object, Object> msg = MapUtil.builder()
+                .put("ids", CollUtil.getFieldValues(truckDtoList, "id", Long.class))
+                .put("created", System.currentTimeMillis())
+                .build();
+
+        String jsonMsg = JSONUtil.toJsonStr(msg);
+
+//        发送消息
+        mqFeign.sendMsg(Constants.MQ.Exchanges.TRUCK_PLAN,
+                Constants.MQ.RoutingKeys.TRUCK_PLAN_COMPLETE,
+                jsonMsg);
+    }
+
+}
 \ No newline at end of file
@@ -5,6 +5,7 @@ import com.sl.ms.work.domain.enums.transporttask.TransportTaskAssignedStatus;
 import com.sl.ms.work.domain.enums.transporttask.TransportTaskLoadingStatus;
 import com.sl.ms.work.domain.enums.transporttask.TransportTaskStatus;
 import com.sl.transport.common.entity.BaseEntity;
+import lombok.Builder;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
@@ -18,6 +19,7 @@ import java.time.LocalDateTime;
 @EqualsAndHashCode(callSuper = false)
 @Accessors(chain = true)
 @TableName("sl_transport_task")
+@Builder
 public class TransportTaskEntity extends BaseEntity {
     private static final long serialVersionUID = 1L;
+package com.sl.ms.work.mq;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.sl.ms.base.api.truck.TruckPlanFeign;
+import com.sl.ms.base.domain.truck.TruckPlanDto;
+import com.sl.ms.driver.api.DriverJobFeign;
+import com.sl.ms.transport.api.TransportLineFeign;
+import com.sl.ms.work.domain.enums.transportorder.TransportOrderSchedulingStatus;
+import com.sl.ms.work.domain.enums.transporttask.TransportTaskAssignedStatus;
+import com.sl.ms.work.domain.enums.transporttask.TransportTaskLoadingStatus;
+import com.sl.ms.work.domain.enums.transporttask.TransportTaskStatus;
+import com.sl.ms.work.entity.TransportOrderEntity;
+import com.sl.ms.work.entity.TransportOrderTaskEntity;
+import com.sl.ms.work.entity.TransportTaskEntity;
+import com.sl.ms.work.service.TransportOrderService;
+import com.sl.ms.work.service.TransportOrderTaskService;
+import com.sl.ms.work.service.TransportTaskService;
+import com.sl.transport.common.constant.Constants;
+import com.sl.transport.common.util.PageResponse;
+import com.sl.transport.domain.TransportLineDTO;
+import com.sl.transport.domain.TransportLineSearchDTO;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.amqp.core.ExchangeTypes;
+import org.springframework.amqp.rabbit.annotation.Exchange;
+import org.springframework.amqp.rabbit.annotation.Queue;
+import org.springframework.amqp.rabbit.annotation.QueueBinding;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+@Slf4j
+public class TransportTaskMQListener {
+
+    @Autowired
+    private DriverJobFeign driverJobFeign;
+
+    @Autowired
+    private TruckPlanFeign truckPlanFeign;
+
+    @Autowired
+    private TransportLineFeign transportLineFeign;
+
+    @Autowired
+    private TransportTaskService transportTaskService;
+
+    @Autowired
+    private TransportOrderTaskService transportOrderTaskService;
+
+    @Autowired
+    private TransportOrderService transportOrderService;
+
+    @RabbitListener(bindings = @QueueBinding(
+            value = @Queue(name = Constants.MQ.Queues.WORK_TRANSPORT_TASK_CREATE),
+            exchange = @Exchange(name = Constants.MQ.Exchanges.TRANSPORT_TASK, type = ExchangeTypes.TOPIC),
+            key = Constants.MQ.RoutingKeys.TRANSPORT_TASK_CREATE
+    ))
+    public void listenTransportTaskMsg(String msg) {
+        //解析消息 {"driverIds":[123,345], "truckPlanId":456, "truckId":1210114964812075008,"totalVolume":4.2,"endOrganId":90001,"totalWeight":7,"transportOrderIdList":[320733749248,420733749248],"startOrganId":100280}
+        JSONObject jsonObject = JSONUtil.parseObj(msg);
+
+//        获取到司机ID列表
+        List<Long> driverIds = CollUtil.getFieldValues(jsonObject, "driverIds", Long.class);
+
+//        分配状态
+        TransportTaskAssignedStatus assignedStatus = CollUtil.isEmpty(driverIds) ? TransportTaskAssignedStatus.MANUAL_DISTRIBUTED : TransportTaskAssignedStatus.DISTRIBUTED;
+
+//        创建运输任务
+        Long transportTaskId = createTransportTask(jsonObject, assignedStatus);
+
+        if (CollUtil.isEmpty(driverIds)) {
+            log.info("生成司机作业单，司机列表为空，需要手动设置司机作业单->msg={}", msg);
+            return;
+        }
+
+//        生成司机作业单
+        driverIds.forEach(driverId -> driverJobFeign.createDriverJob(transportTaskId, driverId));
+    }
+
+    /**
+     * 生成运输任务
+     *
+     * @param jsonObject
+     * @param assignedStatus
+     * @return
+     */
+    @Transactional
+    public Long createTransportTask(JSONObject jsonObject, TransportTaskAssignedStatus assignedStatus) {
+        //根据车辆计划id查询预计发车时间和预计到达时间
+        Long truckPlanId = jsonObject.getLong("truckPlanId");
+        TruckPlanDto truckPlanDto = truckPlanFeign.findById(truckPlanId);
+
+//        创建运输任务
+        TransportTaskEntity transportTaskEntity = TransportTaskEntity.builder()
+                .truckPlanId(jsonObject.getLong("truckPlanId"))
+                .truckId(jsonObject.getLong("truckId"))
+                .startAgencyId(jsonObject.getLong("startOrganId"))
+                .endAgencyId(jsonObject.getLong("endOrganId"))
+                .transportTripsId(jsonObject.getLong("transportTripsId"))
+                .assignedStatus(assignedStatus)
+                .planDepartureTime(truckPlanDto.getPlanDepartureTime())
+                .planArrivalTime(truckPlanDto.getPlanArrivalTime())
+                .status(TransportTaskStatus.PENDING)
+                .build();
+
+        if (CollUtil.isEmpty(jsonObject.getJSONArray("transportOrderIdList"))) {
+            transportTaskEntity.setLoadingStatus(TransportTaskLoadingStatus.EMPTY);
+        } else {
+            transportTaskEntity.setLoadingStatus(TransportTaskLoadingStatus.FULL);
+        }
+
+//        查询线路距离
+        TransportLineSearchDTO transportLineSearchDTO = new TransportLineSearchDTO();
+        transportLineSearchDTO.setPage(1);
+        transportLineSearchDTO.setPageSize(1);
+        transportLineSearchDTO.setStartOrganId(transportTaskEntity.getStartAgencyId());
+        transportLineSearchDTO.setEndOrganId(transportTaskEntity.getEndAgencyId());
+
+        PageResponse<TransportLineDTO> transportLineDTOPageResponse = transportLineFeign.queryPageList(transportLineSearchDTO);
+        TransportLineDTO transportLineDTO = CollUtil.getFirst(transportLineDTOPageResponse.getItems());
+        if (ObjectUtil.isNotEmpty(transportLineDTO)) {
+//            设置距离
+            transportTaskEntity.setDistance(transportLineDTO.getDistance());
+        }
+
+//        保存数据
+        transportTaskService.save(transportTaskEntity);
+
+//        创建运输任务与运单之间的关系
+        createTransportOrderTask(transportTaskEntity.getId(), jsonObject);
+        return transportTaskEntity.getId();
+    }
+
+    /**
+     * 创建运输任务与运单之间的关系
+     *
+     * @param transportTaskId
+     * @param jsonObject
+     */
+    private void createTransportOrderTask(final Long transportTaskId, final JSONObject jsonObject) {
+        JSONArray transportOrderIdList = jsonObject.getJSONArray("transportOrderIdList");
+        if (CollUtil.isEmpty(transportOrderIdList)) {
+            return;
+        }
+
+//        将运单ID列表转成运单实体列表
+        List<TransportOrderTaskEntity> resultList = transportOrderIdList.stream()
+                .map(orderId -> {
+                    TransportOrderTaskEntity transportOrderTaskEntity = new TransportOrderTaskEntity();
+                    transportOrderTaskEntity.setTransportTaskId(transportTaskId);
+                    transportOrderTaskEntity.setTransportOrderId(Convert.toStr(orderId));
+                    return transportOrderTaskEntity;
+                })
+                .collect(Collectors.toList());
+
+//        批量保存运输任务与运单的关联表
+        transportOrderTaskService.batchSaveTransportOrder(resultList);
+
+//        批量标记运单为以调度状态
+        List<TransportOrderEntity> list = transportOrderIdList.stream().map(orderId -> {
+            TransportOrderEntity transportOrderEntity = new TransportOrderEntity();
+            transportOrderEntity.setId(Convert.toStr(orderId));
+//            状态设置为已调度
+            transportOrderEntity.setSchedulingStatus(TransportOrderSchedulingStatus.SCHEDULED);
+            return transportOrderEntity;
+        }).collect(Collectors.toList());
+
+        transportOrderService.updateBatchById(list);
+    }
+}
 \ No newline at end of file
 package com.sl.ms.work.service.impl;
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.convert.Convert;
@@ -10,6 +11,8 @@ import cn.hutool.core.text.CharSequenceUtil;
 import cn.hutool.core.util.NumberUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
 import cn.hutool.json.JSONUtil;
 import com.alibaba.csp.sentinel.datasource.Converter;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -34,6 +37,7 @@ import com.sl.ms.work.entity.TransportOrderTaskEntity;
 import com.sl.ms.work.mapper.TransportOrderMapper;
 import com.sl.ms.work.mapper.TransportOrderTaskMapper;
 import com.sl.ms.work.service.TransportOrderService;
+import com.sl.ms.work.service.TransportTaskService;
 import com.sl.transport.common.constant.Constants;
 import com.sl.transport.common.enums.IdEnum;
 import com.sl.transport.common.exception.SLException;
@@ -75,6 +79,11 @@ public class TransportOrderServiceImpl extends
     private MQFeign mqFeign;
     @Autowired
     private OrganFeign organFeign;
+    @Autowired
+    private TransportOrderTaskMapper transportOrderTaskMapper;
+
+    @Autowired
+    private TransportTaskService transportTaskService;
     @Override
     @Transactional(rollbackFor = Exception.class)
@@ -480,9 +489,87 @@ public class TransportOrderServiceImpl extends
     @Override
     public boolean updateByTaskId(Long taskId) {
-        return false;
-    }
+//        通过运输任务查询运单ID列表
+        List<String> transportOrderIdList = transportTaskService.queryTransportOrderIdListById(taskId);
+        if (CollUtil.isEmpty(transportOrderIdList)) {
+            return false;
+        }
+
+//        查询运单列表
+        List<TransportOrderEntity> transportOrderList = super.listByIds(transportOrderIdList);
+        for (TransportOrderEntity transportOrder : transportOrderList) {
+//            获取将发往目的地的机构
+            OrganDTO organDTO = organFeign.queryById(transportOrder.getNextAgencyId());
+
+//            构建消息实体类
+            String info = CharSequenceUtil.format("快件到达【{}】", organDTO.getName());
+            String transportInfoMsg = TransportInfoMsg.builder()
+                    .transportOrderId(transportOrder.getId())
+                    .status("运送中")
+                    .info(info)
+                    .created(DateUtil.current())
+                    .build().toJson();
+
+//            发送运单跟踪信息
+            mqFeign.sendMsg(Constants.MQ.Exchanges.TRANSPORT_INFO,
+                    Constants.MQ.RoutingKeys.TRANSPORT_INFO_APPEND,
+                    transportInfoMsg);
+
+//            设置当前所在机构ID为下一个机构ID
+            transportOrder.setCurrentAgencyId(transportOrder.getNextAgencyId());
+
+//            解析完整的运输链路，找到下一个机构ID
+            String transportLine = transportOrder.getTransportLine();
+            JSONObject jsonObject = JSONUtil.parseObj(transportLine);
+            Long nextAgencyId = 0L;
+            JSONArray nodeList = jsonObject.getJSONArray("nodeList");
+
+            //这里反向循环主要是考虑到拒收的情况，路线中会存在相同的节点，始终可以查找到后面的节点
+            //正常：A B C D E ，拒收：A B C D E D C B A
+            for (int i = nodeList.size() - 1; i >= 0; i--) {
+                JSONObject node = (JSONObject) nodeList.get(i);
+                Long agencyId = node.getLong("bid");
+                if (ObjectUtil.equal(agencyId, transportOrder.getCurrentAgencyId())) {
+                    if (i == nodeList.size() - 1) {
+//                        已经是最后一个节点了，也就是最后一个机构了
+                        nextAgencyId = agencyId;
+                        transportOrder.setStatus(TransportOrderStatus.ARRIVED_END);
+
+//                        发送消息更新状态
+                        sendUpdateStatusMsg(
+                                ListUtil.toList(transportOrder.getId()),
+                                TransportOrderStatus.ARRIVED_END
+                        );
+                    } else {
+//                        后面还有节点
+                        nextAgencyId = ((JSONObject) nodeList.get(i + 1)).getLong("bid");
+//                        设置运单状态为待调度
+                        transportOrder.setSchedulingStatus(TransportOrderSchedulingStatus.TO_BE_SCHEDULED);
+                    }
+                    break;
+                }
+            }
+//            设置下一个节点ID
+            transportOrder.setNextAgencyId(nextAgencyId);
+
+//            如果运单没有到达终点，需要发送消息到运单调度的交换机中
+//            如果已经到达最终网点,需要发送消息,进行分配快递员作业
+            if (ObjectUtil.notEqual(
+                    transportOrder.getStatus(),
+                    TransportOrderStatus.ARRIVED_END
+            )) {
+                sendTransportOrderMsgToDispatch(transportOrder);
+            } else {
+//                发送消息生产派件任务
+                sendDispatchTaskMsgToDispatch(transportOrder);
+            }
+        }
+
+//        批量更新运单
+        return updateBatchById(transportOrderList);
+    }
+    
     /**
      * 统计各个状态的数量
      *
@@ -512,8 +599,34 @@ public class TransportOrderServiceImpl extends
         return statusCount;
     }
+    /**
+     * 根据运输任务id分页查询运单信息
+     *
+     * @param page             页码
+     * @param pageSize         页面大小
+     * @param taskId           运输任务id
+     * @param transportOrderId 运单id
+     * @return 运单对象分页数据
+     */
     @Override
     public PageResponse<TransportOrderDTO> pageQueryByTaskId(Integer page, Integer pageSize, String taskId, String transportOrderId) {
-        return null;
+//        构建分页查询条件
+        Page<TransportOrderTaskEntity> transportOrderTaskEntityPage = new Page<>(page, pageSize);
+        LambdaQueryWrapper<TransportOrderTaskEntity> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(ObjectUtil.isNotEmpty(transportOrderId), TransportOrderTaskEntity::getTransportTaskId, taskId)
+                .like(ObjectUtil.isNotEmpty(transportOrderId), TransportOrderTaskEntity::getTransportOrderId, transportOrderId)
+                .orderByDesc(TransportOrderTaskEntity::getCreated);
+
+//        根据运输任务ID、运单ID查询运输任务与运单关联关系表
+        Page<TransportOrderTaskEntity> pageResult = transportOrderTaskMapper.selectPage(transportOrderTaskEntityPage, queryWrapper);
+        if (CollUtil.isEmpty(pageResult.getRecords())) {
+            return new PageResponse<>(pageResult);
+        }
+
+//        根据运单ID查询运单，并转化为DTO
+        List<String> transportOrderIds = pageResult.getRecords().stream().map(TransportOrderTaskEntity::getTransportOrderId).collect(Collectors.toList());
+        List<TransportOrderEntity> entities = baseMapper.selectBatchIds(transportOrderIds);
+
+        return PageResponse.of(BeanUtil.copyToList(entities, TransportOrderDTO.class));
     }
 }