Merge branch '1.0' of http://120.76.84.145:10101/gitblit/r/java/Robotaxi in...

puzhibing

2026-05-12 08cc6d5cf7e93b75cfabe7dcc2aeaa9afa1117eb

 xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/controller/OrderMissionController.java

@@ -54,6 +54,20 @@
@Api(tags = "订单任务Api")
public class OrderMissionController {

    /**
     * 共享线程池，用于推送司机位置轨迹，避免每次请求创建新线程池导致资源泄漏
     */
    private static final ThreadPoolExecutor DRIVER_LOCATION_EXECUTOR = new ThreadPoolExecutor(
            2, 4, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(500),
            r -> {
                Thread t = new Thread(r, "driver-location-push");
                t.setDaemon(true);
                return t;
            },
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    @Resource
    private XPUUtil xpuUtil;
    @Resource
@@ -108,7 +122,7 @@
                taskActionBuilder.setOrderId(dto.getLastOrderId());
                taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
                taskActionBuilder.setActionType(dto.getTaskActionType());
                taskBuilder.setPreActions(0, taskActionBuilder);
                taskBuilder.addPreActions(taskActionBuilder.build());
            }
            taskListBuilder.addTasks(taskBuilder.build());
        }else if(dto.getOrderType().equals(com.xiaopeng.api.vo.OrderType.USER_ORDER)){
@@ -149,7 +163,7 @@
                        taskActionBuilder.setOrderId(dto.getLastOrderId());
                        taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
                        taskActionBuilder.setActionType(dto.getTaskActionType());
                        taskBuilder.setPreActions(0, taskActionBuilder);
                        taskBuilder.addPreActions(taskActionBuilder.build());
                    }
                    taskListBuilder.addTasks(taskBuilder.build());
                }else{
@@ -188,7 +202,7 @@
                        taskActionBuilder.setOrderId(dto.getLastOrderId());
                        taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
                        taskActionBuilder.setActionType(dto.getTaskActionType());
                        taskBuilder.setPreActions(0, taskActionBuilder);
                        taskBuilder.addPreActions(taskActionBuilder.build());
                    }
                    taskListBuilder.addTasks(taskBuilder.build());
                }
@@ -232,7 +246,7 @@
                        taskActionBuilder.setOrderId(dto.getLastOrderId());
                        taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
                        taskActionBuilder.setActionType(dto.getTaskActionType());
                        taskBuilder.setPreActions(0, taskActionBuilder);
                        taskBuilder.addPreActions(taskActionBuilder.build());
                    }
                    taskListBuilder.addTasks(taskBuilder.build());
                }else{
@@ -270,7 +284,7 @@
                        taskActionBuilder.setOrderId(dto.getLastOrderId());
                        taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
                        taskActionBuilder.setActionType(dto.getTaskActionType());
                        taskBuilder.setPreActions(0, taskActionBuilder);
                        taskBuilder.addPreActions(taskActionBuilder.build());
                    }
                    taskListBuilder.addTasks(taskBuilder.build());
                }
@@ -311,7 +325,7 @@
                taskActionBuilder.setOrderId(dto.getLastOrderId());
                taskActionBuilder.setTaskId(dto.getLastXpuTaskId());
                taskActionBuilder.setActionType(dto.getTaskActionType());
                taskBuilder.setPreActions(0, taskActionBuilder);
                taskBuilder.addPreActions(taskActionBuilder.build());
            }
            taskListBuilder.addTasks(taskBuilder.build());
        }
@@ -457,21 +471,40 @@
     */
    @GetMapping("/base/v1/order/acceptingOrder")
    public R acceptingOrder(Long orderId, String code, Long vehicleId, Double startLon, Double startLat){
        log.info("【模拟接单】开始，orderId={}, code={}, vehicleId={}, startLon={}, startLat={}", orderId, code, vehicleId, startLon, startLat);
        if(null == vehicleId){
            vehicleId = 11L;//默认使用造的测试车辆
            log.info("【模拟接单】vehicleId为空，使用默认测试车辆 vehicleId={}", vehicleId);
        }
        if(null == startLat || null == startLon){
            startLat = 23.146815D;
            startLon = 113.459765D;
            log.info("【模拟接单】起点坐标为空，使用默认坐标 startLon={}, startLat={}", startLon, startLat);
        }
        XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
        log.info("【模拟接单】查询车辆信息，vehicleId={}, vin={}", vehicleId, xpVehicle != null ? xpVehicle.getVehicleVin() : "null");
        XpOrder xpOrder = null;
        if(null != orderId){
            xpOrder = xpOrderClient.queryOrderById(orderId).getData();
            log.info("【模拟接单】按orderId查询订单，orderId={}, orderNo={}", orderId, xpOrder != null ? xpOrder.getOrderNumber() : "null");
        }
        if(StringUtils.isNotEmpty(code)){
            xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
            log.info("【模拟接单】按orderNo查询订单，code={}, orderId={}", code, xpOrder != null ? xpOrder.getId() : "null");
        }

        orderId = xpOrder.getId();
        log.info("【模拟接单】订单信息，orderId={}, appUserId={}, startLon={}, startLat={}", orderId, xpOrder.getAppUserId(), xpOrder.getStartLon(), xpOrder.getStartLat());
        OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
        dto.setOrderId(orderId);
        LonLatDto origin = new LonLatDto();
        origin.setLongitude(startLon);
        origin.setLatitude(startLat);
        dto.setOrigin(origin);

        //保存车辆实时位置到redis
        redisTemplate.opsForGeo().add("vehiclePosition:" + xpVehicle.getVehicleVin(), new Point(startLon, startLat), xpVehicle.getVehicleVin());
        log.info("【模拟接单】保存车辆位置到Redis，vin={}, lon={}, lat={}", xpVehicle.getVehicleVin(), startLon, startLat);

        //保存车辆实时信息到mongodb
        VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
@@ -507,32 +540,31 @@
            mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), update, VehiclePosition.class);
        }

        orderId = xpOrder.getId();
        OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
        dto.setOrderId(orderId);
        LonLatDto origin = new LonLatDto();
        origin.setLongitude(startLon);
        origin.setLatitude(startLat);
        dto.setOrigin(origin);
        LonLatDto destination = new LonLatDto();
        destination.setLongitude(xpOrder.getStartLon());
        destination.setLatitude(xpOrder.getStartLat());
        dto.setDestination(destination);
        dto.setRouteType(1);
        dto.setVehicleId(xpOrder.getVehicleId());
        log.info("【模拟接单】请求规划接驾路线，origin=[{},{}], destination=[{},{}]", startLon, startLat, xpOrder.getStartLon(), xpOrder.getStartLat());
        R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
        if (200 != routeVoR.getCode()) {
            log.error("【模拟接单】获取订单线路和运费失败，orderId={}, code={}, msg={}", orderId, routeVoR.getCode(), routeVoR.getMsg());
            throw new RuntimeException("获取订单线路和运费失败");
        }
        RouteVo routeVo = routeVoR.getData();
        log.info("【模拟接单】获取接驾路线成功，orderId={}, distance={}, duration={}, polylineSize={}", orderId, routeVo.getDistance(), routeVo.getDuration(), routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);
        //缓存数据，用于后续推给乘客导航线路
        redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
        log.info("【模拟接单】缓存接驾导航数据成功，key=ORDER_NAVIGATION_START_DATA:{}", xpOrder.getAppUserId());

        PopOrderDto dto1 = new PopOrderDto();
        dto1.setOrderId(Long.valueOf(orderId));
        dto1.setXpVehicleVin(xpVehicle.getVehicleVin());
        dto1.setOrderType(com.xiaopeng.api.vo.OrderType.USER_ORDER);
        log.info("【模拟接单】调用popOrder，orderId={}, vin={}", orderId, xpVehicle.getVehicleVin());
        R<?> r = xpOrderClient.popOrder(dto1);
        log.info("【模拟接单】popOrder结果，orderId={}, code={}", orderId, r.getCode());

        //构建推送消息
        Map<String, Object> params = new HashMap<>();
@@ -547,11 +579,14 @@
        SendMessageDTO dto2 = new SendMessageDTO();
        dto2.setAppUserId(appUserId + "");
        dto2.setMessage(message);
        log.info("【模拟接单】推送订单状态(status=3)给用户，appUserId={}, orderId={}", appUserId, orderId);
        R<String> stringR = xpPushMessageClient.sendStatus(dto2);
        if (R.isError(stringR)) {
            log.error("推送消息失败：{}", stringR.getMsg());
            log.error("【模拟接单】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, orderId, stringR.getMsg());
        }
        log.info("【模拟接单】更新订单状态为PICK_UP，orderId={}", orderId);
        xpOrderClient.updateOrderStatus(orderId, OrderStatusEnum.PICK_UP.getCode(), false);
        log.info("【模拟接单】流程完成，orderId={}", orderId);

//        PushOrderRouteDTO dto3 = new PushOrderRouteDTO();
//        dto3.setOrderId(orderId);
@@ -573,8 +608,10 @@
     */
    @GetMapping("/base/v1/order/pushStartDriverLocation")
    private void pushStartDriverLocation(Long vehicleId, Long orderId, String code){
        log.info("【推送接驾轨迹】开始，vehicleId={}, orderId={}, code={}", vehicleId, orderId, code);
        if(null == vehicleId){
            vehicleId = 1L;
            log.info("【推送接驾轨迹】vehicleId为空，使用默认 vehicleId={}", vehicleId);
        }
        XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
        XpOrder xpOrder = null;
@@ -587,31 +624,29 @@
        orderId = xpOrder.getId();
        String vin = xpVehicle.getVehicleVin();
        Long appUserId = xpOrder.getAppUserId();
        log.info("【推送接驾轨迹】订单信息，orderId={}, orderNo={}, vin={}, appUserId={}", orderId, xpOrder.getOrderNumber(), vin, appUserId);
        Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId());
        RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
//        RouteVo routeVo =new RouteVo();
//        ArrayList<LonLatDto> lonLatDtos = new ArrayList<>();
//        LonLatDto lonLatDto1 = new LonLatDto();
//        lonLatDto1.setLatitude(30.575685);
//        lonLatDto1.setLongitude(104.001118);
//        lonLatDtos.add(lonLatDto1);
//        routeVo.setPolyline(lonLatDtos);
        log.info("【推送接驾轨迹】获取接驾导航缓存数据，orderId={}, polylineSize={}", orderId, routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);


        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1000));
        Long finalOrderId = orderId;
        Long finalOrderId1 = orderId;
        threadPoolExecutor.execute(() -> {
            //等待10秒后开始执行车子位移
        DRIVER_LOCATION_EXECUTOR.execute(() -> {
            //等待1秒后开始执行车子位移
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
                Thread.currentThread().interrupt();
                log.error("pushStartDriverLocation 线程被中断", e);
                return;
            }
            List<LonLatDto> polyline = routeVo.getPolyline();
            log.info("【推送接驾轨迹】开始逐点推送位置，orderId={}, 总点数={}", finalOrderId, polyline.size());
            int idx = 0;
            for (LonLatDto lonLatDto : polyline) {
                Double latitude = lonLatDto.getLatitude();
                Double longitude = lonLatDto.getLongitude();
                log.info("【推送接驾轨迹】推送第{}/{}个点，orderId={}, lon={}, lat={}", ++idx, polyline.size(), finalOrderId, longitude, latitude);

                //保存车辆实时位置到redis
                redisTemplate.opsForGeo().add("vehiclePosition:" + vin, new Point(longitude, latitude), vin);
@@ -629,6 +664,8 @@
                    vehiclePosition.setMileageRange(300f);
                    vehiclePosition.setHasOrder(0);
                    vehiclePosition.setOrderId(finalOrderId1);
                    vehiclePosition.setTotalOdometer(10000L);
                    vehiclePosition.setAddTime(System.currentTimeMillis());
                    mongoTemplate.save(vehiclePosition);
                }else{
                    vehiclePosition.setOrderId(finalOrderId1);
@@ -640,7 +677,9 @@
                            .set("currentElectricity", 80)
                            .set("mileageRange", 300f)
                            .set("hasOrder", 0)
                            .set("orderId", finalOrderId1);
                            .set("orderId", finalOrderId1)
                            .set("totalOdometer", 10000L)
                            .set("addTime", System.currentTimeMillis());;
                    mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(vin)), update, VehiclePosition.class);
                }
                //调用推送服务接口
@@ -652,7 +691,6 @@
                    dto.setLatitude(latitude);
                    dto.setDuration(10.0);
                    dto.setDistance(2.0);
                    dto.setSpeed(2.0f);
                    dto.setDirection(60);
                    dto.setMessageType(PushMessageTypeEnum.ORDER_ROUTE.getDesc());
                    xpPushMessageClient.pushOrderRoute(dto);
@@ -662,10 +700,13 @@
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                    Thread.currentThread().interrupt();
                    log.error("pushStartDriverLocation 循环线程被中断", e);
                    return;
                }
            }

            log.info("【推送接驾轨迹】所有点推送完毕，推送status=4给用户，orderId={}, appUserId={}", finalOrderId, appUserId);
            //构建推送消息
            Map<String, Object> params = new HashMap<>();
            Map<String, Object> content = new HashMap<>();
@@ -680,9 +721,11 @@
            dto2.setMessage(message);
            R<String> stringR = xpPushMessageClient.sendStatus(dto2);
            if (R.isError(stringR)) {
                log.error("推送消息失败：{}", stringR.getMsg());
                log.error("【推送接驾轨迹】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, finalOrderId, stringR.getMsg());
            }
            log.info("【推送接驾轨迹】更新订单状态为PICK_UP_GUESTS，orderId={}", finalOrderId);
            xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.PICK_UP_GUESTS.getCode(), false);
            log.info("【推送接驾轨迹】流程完成，orderId={}", finalOrderId);
        });

    }
@@ -696,6 +739,7 @@
     */
    @GetMapping("/base/v1/order/updateOrderStatus")
    public R updateOrderStatus(Long orderId, String code, Integer status) {
        log.info("【模拟修改订单状态】开始，orderId={}, code={}, status={}", orderId, code, status);
        XpOrder xpOrder = null;
        if(null != orderId){
            xpOrder = xpOrderClient.queryOrderById(orderId).getData();
@@ -704,6 +748,7 @@
            xpOrder = xpOrderClient.queryOrderByOrderNo(code).getData();
        }
        orderId = xpOrder.getId();
        log.info("【模拟修改订单状态】订单信息，orderId={}, orderNo={}, appUserId={}", orderId, xpOrder.getOrderNumber(), xpOrder.getAppUserId());
        //构建推送消息
        Map<String, Object> params = new HashMap<>();
        Map<String, Object> content = new HashMap<>();
@@ -716,15 +761,19 @@
        SendMessageDTO dto2 = new SendMessageDTO();
        dto2.setAppUserId(xpOrder.getAppUserId() + "");
        dto2.setMessage(message);
        log.info("【模拟修改订单状态】推送状态消息给用户，appUserId={}, orderId={}, status={}", xpOrder.getAppUserId(), orderId, status);
        R<String> stringR = xpPushMessageClient.sendStatus(dto2);
        if (R.isError(stringR)) {
            log.error("推送消息失败：{}", stringR.getMsg());
            log.error("【模拟修改订单状态】推送消息失败，appUserId={}, orderId={}, msg={}", xpOrder.getAppUserId(), orderId, stringR.getMsg());
        }
        log.info("【模拟修改订单状态】更新订单状态，orderId={}, status={}", orderId, status);
        xpOrderClient.updateOrderStatus(orderId, status, false);
        if(5 == status){
            log.info("【模拟修改订单状态】status=5，主动推送全程轨迹，orderId={}", orderId);
            //主动推一次全程轨迹
            Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId());
            RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
            log.info("【模拟修改订单状态】获取送驾导航缓存，orderId={}, polylineSize={}", orderId, routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("type", "ORDER_ROUTE");
            jsonObject.put("timestamp", System.currentTimeMillis());
@@ -749,21 +798,25 @@
            SendMessageDTO messageDTO = new SendMessageDTO();
            messageDTO.setAppUserId(xpOrder.getAppUserId().toString());
            messageDTO.setMessage(jsonObject.toJSONString());
            log.info("【模拟修改订单状态】推送全程轨迹，appUserId={}, orderId={}", xpOrder.getAppUserId(), orderId);
            xpPushMessageClient.sendRoute(messageDTO);
        }
        log.info("【模拟修改订单状态】完成，orderId={}, status={}", orderId, status);
        return R.ok();
    }



    /**
     * 推送司机接驾轨迹和实时位置
     * 推送司机送驾轨迹和实时位置
     * @param orderId
     */
    @GetMapping("/base/v1/order/pushEndDriverLocation")
    private void pushEndDriverLocation(Long vehicleId, Long orderId, String code){
        log.info("【推送送驾轨迹】开始，vehicleId={}, orderId={}, code={}", vehicleId, orderId, code);
        if(null == vehicleId){
            vehicleId = 1L;
            log.info("【推送送驾轨迹】vehicleId为空，使用默认 vehicleId={}", vehicleId);
        }
        XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
        XpOrder xpOrder = null;
@@ -779,22 +832,27 @@
        Object cacheObject = redisService.getCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId());
        RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
        log.info("开始实施推送车辆位置和剩余导航线路 {} {}", xpOrder.getOrderNumber(), JSON.toJSONString(routeVo));
        log.info("【推送送驾轨迹】获取送驾导航缓存，orderId={}, vin={}, appUserId={}, polylineSize={}", orderId, vin, appUserId, routeVo.getPolyline() != null ? routeVo.getPolyline().size() : 0);

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(1000));
        Long finalOrderId = orderId;
        Long finalOrderId1 = orderId;
        threadPoolExecutor.execute(() -> {
            //等待10秒后开始执行车子位移
        DRIVER_LOCATION_EXECUTOR.execute(() -> {
            //等待1秒后开始执行车子位移
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
                Thread.currentThread().interrupt();
                log.error("pushEndDriverLocation 线程被中断", e);
                return;
            }

            List<LonLatDto> polyline = routeVo.getPolyline();
            log.info("【推送送驾轨迹】开始逐点推送位置，orderId={}, 总点数={}", finalOrderId, polyline.size());
            int idx = 0;
            for (LonLatDto lonLatDto : polyline) {
                Double latitude = lonLatDto.getLatitude();
                Double longitude = lonLatDto.getLongitude();
                log.info("【推送送驾轨迹】推送第{}/{}个点，orderId={}, lon={}, lat={}", ++idx, polyline.size(), finalOrderId, longitude, latitude);

                //保存车辆实时位置到redis
                redisTemplate.opsForGeo().add("vehiclePosition:" + vin, new Point(longitude, latitude), vin);
@@ -812,6 +870,8 @@
                    vehiclePosition.setMileageRange(300f);
                    vehiclePosition.setHasOrder(0);
                    vehiclePosition.setOrderId(finalOrderId1);
                    vehiclePosition.setTotalOdometer(10000L);
                    vehiclePosition.setAddTime(System.currentTimeMillis());
                    mongoTemplate.save(vehiclePosition);
                }else{
                    vehiclePosition.setOrderId(finalOrderId1);
@@ -823,7 +883,9 @@
                            .set("currentElectricity", 80)
                            .set("mileageRange", 300f)
                            .set("hasOrder", 0)
                            .set("orderId", finalOrderId1);
                            .set("orderId", finalOrderId1)
                            .set("totalOdometer", 10000L)
                            .set("addTime", System.currentTimeMillis());;
                    mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(vin)), update, VehiclePosition.class);
                }
                //调用推送服务接口
@@ -835,7 +897,6 @@
                    dto.setLatitude(latitude);
                    dto.setDuration(20.0);
                    dto.setDistance(10.0);
                    dto.setSpeed(10.0f);
                    dto.setDirection(60);
                    dto.setMessageType(PushMessageTypeEnum.ORDER_ROUTE.getDesc());
                    R<String> stringR = xpPushMessageClient.pushOrderRoute(dto);
@@ -851,14 +912,17 @@
                    xpOrderClient.saveVehicleLocation(orderTrajectory);
                }

                //5秒钟循环一次
                //1秒钟循环一次
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                    Thread.currentThread().interrupt();
                    log.error("pushEndDriverLocation 循环线程被中断", e);
                    return;
                }
            }

            log.info("【推送送驾轨迹】所有点推送完毕，推送status=7给用户，orderId={}, appUserId={}", finalOrderId, appUserId);
            //构建推送消息
            Map<String, Object> params = new HashMap<>();
            Map<String, Object> content = new HashMap<>();
@@ -873,11 +937,12 @@
            dto2.setMessage(message);
            R<String> stringR = xpPushMessageClient.sendStatus(dto2);
            if (R.isError(stringR)) {
                log.error("推送消息失败：{}", stringR.getMsg());
                log.error("【推送送驾轨迹】推送消息失败，appUserId={}, orderId={}, msg={}", appUserId, finalOrderId, stringR.getMsg());
            }
            log.info("【推送送驾轨迹】更新订单状态为SEE_OFF_GUESTS，orderId={}", finalOrderId);
            xpOrderClient.updateOrderStatus(finalOrderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), false);
            log.info("【推送送驾轨迹】流程完成，orderId={}", finalOrderId);
        });
    }


}