新增高德电动车路径规划支持，完善配送费计算与路线规划接口

shaofan
1 parent f3ec2e0c
Showing 9 changed files with 391 additions and 3 deletions
src/main/java/com/diligrp/rider/config/AmapProperties.java
src/main/java/com/diligrp/rider/controller/OpenApiController.java
src/main/java/com/diligrp/rider/dto/OpenRouteCalcDTO.java
src/main/java/com/diligrp/rider/service/amap/AmapRouteClient.java
src/main/java/com/diligrp/rider/service/impl/DeliveryFeeServiceImpl.java
src/main/java/com/diligrp/rider/vo/RouteCalcVO.java
src/main/resources/application.yml
src/test/java/com/diligrp/rider/controller/OpenApiControllerTest.java
src/test/java/com/diligrp/rider/service/impl/DeliveryFeeServiceImplTest.java
+package com.diligrp.rider.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * 高德 Web 服务 API 配置（电动车路径规划）。
+ */
+@Data
+@Configuration
+@ConfigurationProperties(prefix = "amap")
+public class AmapProperties {
+
+    /** 是否启用高德 ETA；false 时调用直接返回空，由上游降级到直线距离公式 */
+    private boolean enabled = true;
+
+    /** 高德 Web 服务 API Key */
+    private String key;
+
+    /** 高德 Web 服务基础 URL */
+    private String baseUrl = "https://restapi.amap.com";
+
+    /** HTTP 连接超时（毫秒） */
+    private int connectTimeoutMillis = 3000;
+
+    /** HTTP 读取超时（毫秒） */
+    private int readTimeoutMillis = 3000;
+}
@@ -4,15 +4,21 @@ import com.diligrp.rider.common.exception.BizException;
 import com.diligrp.rider.common.result.Result;
 import com.diligrp.rider.dto.DeliveryFeeCalcDTO;
 import com.diligrp.rider.dto.OpenDeliveryFeeCalcDTO;
+import com.diligrp.rider.dto.OpenRouteCalcDTO;
 import com.diligrp.rider.entity.OpenApp;
 import com.diligrp.rider.service.DeliveryFeeService;
 import com.diligrp.rider.service.OpenAppService;
+import com.diligrp.rider.service.amap.AmapRouteClient;
+import com.diligrp.rider.util.GeoUtil;
 import com.diligrp.rider.vo.DeliveryFeeResultVO;
+import com.diligrp.rider.vo.RouteCalcVO;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
  
+import java.util.Optional;
+
 /**
  * 开放平台对外接口
  * 路径前缀 /api/open/** 受 OpenApiInterceptor 签名鉴权保护
@@ -25,6 +31,7 @@ public class OpenApiController {
  
     private final DeliveryFeeService deliveryFeeService;
     private final OpenAppService openAppService;
+    private final AmapRouteClient amapRouteClient;
  
     /**
      * 计算配送费（对外开放版）
@@ -55,6 +62,32 @@ public class OpenApiController {
         return Result.success(deliveryFeeService.isServiceEnabled(resolveCityId(request), orderType));
     }
  
+    /**
+     * 路线计算：传入起止经纬度，返回距离（米）与导航耗时（秒）。
+     * - distance 始终有值：优先高德电动车路径距离，失败时回退到直线距离
+     * - duration 高德未命中时为 null
+     */
+    @PostMapping("/route/calc")
+    public Result<RouteCalcVO> routeCalc(@Valid @RequestBody OpenRouteCalcDTO dto) {
+        Optional<AmapRouteClient.AmapRoute> route = amapRouteClient.getElectrobikeRoute(
+                dto.getStartLng(), dto.getStartLat(), dto.getEndLng(), dto.getEndLat());
+        if (route.isPresent()) {
+            return Result.success(new RouteCalcVO(route.get().distanceMeters(), route.get().durationSeconds()));
+        }
+        double km;
+        try {
+            km = GeoUtil.calcDistanceKm(
+                    Double.parseDouble(dto.getStartLat()),
+                    Double.parseDouble(dto.getStartLng()),
+                    Double.parseDouble(dto.getEndLat()),
+                    Double.parseDouble(dto.getEndLng()));
+        } catch (Exception e) {
+            throw new BizException("起止经纬度格式错误");
+        }
+        int distanceMeters = (int) Math.round(km * 1000);
+        return Result.success(new RouteCalcVO(distanceMeters, null));
+    }
+
     private Long resolveCityId(HttpServletRequest request) {
         String appKey = request.getHeader("X-App-Key");
         OpenApp app = openAppService.getByAppKey(appKey);
+package com.diligrp.rider.dto;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+/**
+ * 开放平台路线计算请求 DTO。
+ */
+@Data
+public class OpenRouteCalcDTO {
+
+    /** 起点经度 */
+    @NotNull(message = "起点经度不能为空")
+    private String startLng;
+
+    /** 起点纬度 */
+    @NotNull(message = "起点纬度不能为空")
+    private String startLat;
+
+    /** 终点经度 */
+    @NotNull(message = "终点经度不能为空")
+    private String endLng;
+
+    /** 终点纬度 */
+    @NotNull(message = "终点纬度不能为空")
+    private String endLat;
+}
+package com.diligrp.rider.service.amap;
+
+import com.diligrp.rider.config.AmapProperties;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.Optional;
+
+/**
+ * 高德电动车路径规划客户端（/v5/direction/electrobike）。
+ *
+ * 任何失败场景（未启用 / Key 缺失 / 坐标非法 / 起止同点 / HTTP 异常 / status != "1" / paths 空 / 字段缺失）
+ * 均返回 Optional.empty()，由调用方决定降级策略。
+ */
+@Slf4j
+@Component
+public class AmapRouteClient {
+
+    private final AmapProperties amapProperties;
+    private final ObjectMapper objectMapper;
+    private final HttpClient httpClient;
+
+    public AmapRouteClient(AmapProperties amapProperties, ObjectMapper objectMapper) {
+        this.amapProperties = amapProperties;
+        this.objectMapper = objectMapper;
+        this.httpClient = HttpClient.newBuilder()
+                .connectTimeout(Duration.ofMillis(amapProperties.getConnectTimeoutMillis()))
+                .build();
+    }
+
+    /** 高德电动车路径规划结果：原始距离（米）与耗时（秒）。 */
+    public record AmapRoute(int distanceMeters, int durationSeconds) {}
+
+    /**
+     * 调用高德电动车路径规划，返回原始距离（米）+ 耗时（秒）。
+     */
+    public Optional<AmapRoute> getElectrobikeRoute(String startLng, String startLat,
+                                                  String endLng, String endLat) {
+        if (!amapProperties.isEnabled()) {
+            return Optional.empty();
+        }
+        if (amapProperties.getKey() == null || amapProperties.getKey().isBlank()) {
+            log.warn("Amap key 未配置，跳过高德调用");
+            return Optional.empty();
+        }
+
+        double sLng;
+        double sLat;
+        double eLng;
+        double eLat;
+        try {
+            sLng = Double.parseDouble(startLng);
+            sLat = Double.parseDouble(startLat);
+            eLng = Double.parseDouble(endLng);
+            eLat = Double.parseDouble(endLat);
+        } catch (Exception e) {
+            return Optional.empty();
+        }
+        if (sLng == eLng && sLat == eLat) {
+            return Optional.empty();
+        }
+
+        String origin = String.format("%.6f,%.6f", sLng, sLat);
+        String destination = String.format("%.6f,%.6f", eLng, eLat);
+        String url = amapProperties.getBaseUrl() + "/v5/direction/electrobike"
+                + "?key=" + URLEncoder.encode(amapProperties.getKey(), StandardCharsets.UTF_8)
+                + "&origin=" + URLEncoder.encode(origin, StandardCharsets.UTF_8)
+                + "&destination=" + URLEncoder.encode(destination, StandardCharsets.UTF_8)
+                + "&show_fields=cost";
+
+        try {
+            HttpRequest request = HttpRequest.newBuilder()
+                    .uri(URI.create(url))
+                    .timeout(Duration.ofMillis(amapProperties.getReadTimeoutMillis()))
+                    .GET()
+                    .build();
+            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+            if (response.statusCode() != 200) {
+                log.warn("Amap electrobike HTTP {} body={}", response.statusCode(), trim(response.body()));
+                return Optional.empty();
+            }
+            JsonNode root = objectMapper.readTree(response.body());
+            String status = root.path("status").asText();
+            if (!"1".equals(status)) {
+                log.warn("Amap electrobike status={} info={} infocode={}",
+                        status, root.path("info").asText(), root.path("infocode").asText());
+                return Optional.empty();
+            }
+            JsonNode paths = root.path("route").path("paths");
+            if (!paths.isArray() || paths.isEmpty()) {
+                log.warn("Amap electrobike paths 空 body={}", trim(response.body()));
+                return Optional.empty();
+            }
+            JsonNode first = paths.get(0);
+            long distanceMeters = first.path("distance").asLong(-1);
+            long durationSeconds = first.path("cost").path("duration").asLong(-1);
+            if (distanceMeters < 0 || durationSeconds <= 0) {
+                log.warn("Amap electrobike 字段异常 distance={} duration={} body={}",
+                        distanceMeters, durationSeconds, trim(response.body()));
+                return Optional.empty();
+            }
+            return Optional.of(new AmapRoute((int) distanceMeters, (int) durationSeconds));
+        } catch (Exception e) {
+            log.warn("Amap electrobike 调用失败 err={}", e.getMessage());
+            return Optional.empty();
+        }
+    }
+
+    /**
+     * 返回预计骑行分钟数（向上取整）。委托 {@link #getElectrobikeRoute}。
+     */
+    public Optional<Integer> getElectrobikeDurationMinutes(String startLng, String startLat,
+                                                          String endLng, String endLat) {
+        return getElectrobikeRoute(startLng, startLat, endLng, endLat)
+                .map(r -> (int) Math.ceil(r.durationSeconds() / 60.0));
+    }
+
+    private String trim(String body) {
+        if (body == null) return "";
+        return body.length() > 300 ? body.substring(0, 300) : body;
+    }
+}
@@ -6,6 +6,7 @@ import com.diligrp.rider.dto.DeliveryPricingRuleDTO;
 import com.diligrp.rider.dto.DeliveryFeeCalcDTO;
 import com.diligrp.rider.service.CityService;
 import com.diligrp.rider.service.DeliveryFeeService;
+import com.diligrp.rider.service.amap.AmapRouteClient;
 import com.diligrp.rider.util.GeoUtil;
 import com.diligrp.rider.vo.DeliveryFeeResultVO;
 import lombok.RequiredArgsConstructor;
@@ -20,6 +21,7 @@ import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
  
 /**
  * 配送费计算引擎
@@ -31,6 +33,7 @@ import java.util.List;
 public class DeliveryFeeServiceImpl implements DeliveryFeeService {
  
     private final CityService cityService;
+    private final AmapRouteClient amapRouteClient;
  
     @Override
     public DeliveryFeeResultVO calcFee(DeliveryFeeCalcDTO dto) {
@@ -182,7 +185,14 @@ public class DeliveryFeeServiceImpl implements DeliveryFeeService {
  
         BigDecimal total = moneyBasic.add(moneyDistance).add(moneyWeight).add(moneyPiece).add(moneyTime);
         result.setTotalFee(applyMinFee(total, typeConfig, result));
-        result.setEstimatedMinutes(calcEstimatedMinutes(pricingConfig, distanceKm));
+
+        // ETA：优先取高德电动车路径耗时，失败降级到 distance_basic_time + 公式
+        Optional<Integer> amapMinutes = amapRouteClient.getElectrobikeDurationMinutes(
+                dto.getStartLng(), dto.getStartLat(), dto.getEndLng(), dto.getEndLat());
+        int estimatedMinutes = amapMinutes.isPresent()
+                ? amapMinutes.get()
+                : calcEstimatedMinutes(pricingConfig, distanceKm);
+        result.setEstimatedMinutes(estimatedMinutes);
  
         return result;
     }
+package com.diligrp.rider.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 开放平台路线计算结果 VO。
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RouteCalcVO {
+
+    /** 距离（米）。高德命中时为路径距离，否则为直线距离向上取整。 */
+    private Integer distance;
+
+    /** 导航耗时（秒）。高德未命中时为 null。 */
+    private Integer duration;
+}
@@ -32,12 +32,19 @@ jwt:
   expire: 604800  # 7天，单位秒
  
 jpush:
-  enabled: false                          # 未配置 AppKey 前置 false，避免启动时报错
+  enabled: true                          # 未配置 AppKey 前置 false，避免启动时报错
   app-key: fd6e826ae6e67eaf7a7062c4
   master-secret: 6eaa9a8d11493b56812b6ee9
   apns-production: false                  # iOS APNs：true=生产 false=开发
   time-to-live: 86400                     # 离线消息保留秒数（默认 1 天）
  
+amap:
+  enabled: true                           # false 时跳过高德调用，ETA 走直线距离 + 公式
+  key: 5aa7f0260a51dcb2f1dda3130f9a0dbd   # 高德 Web 服务 API Key，可由环境变量注入
+  base-url: https://restapi.amap.com
+  connect-timeout-millis: 3000
+  read-timeout-millis: 3000
+
 logging:
   level:
     com.diligrp.rider: debug
+package com.diligrp.rider.controller;
+
+import com.diligrp.rider.common.exception.BizException;
+import com.diligrp.rider.common.result.Result;
+import com.diligrp.rider.dto.OpenRouteCalcDTO;
+import com.diligrp.rider.service.DeliveryFeeService;
+import com.diligrp.rider.service.OpenAppService;
+import com.diligrp.rider.service.amap.AmapRouteClient;
+import com.diligrp.rider.util.GeoUtil;
+import com.diligrp.rider.vo.RouteCalcVO;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class OpenApiControllerTest {
+
+    private final DeliveryFeeService deliveryFeeService = mock(DeliveryFeeService.class);
+    private final OpenAppService openAppService = mock(OpenAppService.class);
+    private final AmapRouteClient amapRouteClient = mock(AmapRouteClient.class);
+    private final OpenApiController controller =
+            new OpenApiController(deliveryFeeService, openAppService, amapRouteClient);
+
+    @Test
+    void routeCalcShouldReturnAmapValuesWhenHit() {
+        OpenRouteCalcDTO dto = dto("121.4737", "31.2304", "121.5067", "31.2454");
+        when(amapRouteClient.getElectrobikeRoute(
+                dto.getStartLng(), dto.getStartLat(), dto.getEndLng(), dto.getEndLat()))
+                .thenReturn(Optional.of(new AmapRouteClient.AmapRoute(4830, 1080)));
+
+        Result<RouteCalcVO> result = controller.routeCalc(dto);
+
+        assertEquals(0, result.getCode());
+        assertEquals(4830, result.getData().getDistance());
+        assertEquals(1080, result.getData().getDuration());
+    }
+
+    @Test
+    void routeCalcShouldFallbackToGeoUtilWhenAmapMisses() {
+        OpenRouteCalcDTO dto = dto("121.4737", "31.2304", "121.4737", "31.2574");
+        when(amapRouteClient.getElectrobikeRoute(any(), any(), any(), any()))
+                .thenReturn(Optional.empty());
+
+        Result<RouteCalcVO> result = controller.routeCalc(dto);
+
+        int expected = (int) Math.round(
+                GeoUtil.calcDistanceKm(31.2304, 121.4737, 31.2574, 121.4737) * 1000);
+        assertEquals(0, result.getCode());
+        assertNotNull(result.getData().getDistance());
+        assertEquals(expected, result.getData().getDistance());
+        assertNull(result.getData().getDuration());
+    }
+
+    @Test
+    void routeCalcShouldThrowOnInvalidCoordinatesWhenAmapMisses() {
+        OpenRouteCalcDTO dto = dto("not-a-number", "31.2304", "121.5067", "31.2454");
+        when(amapRouteClient.getElectrobikeRoute(any(), any(), any(), any()))
+                .thenReturn(Optional.empty());
+
+        assertThrows(BizException.class, () -> controller.routeCalc(dto));
+    }
+
+    private OpenRouteCalcDTO dto(String startLng, String startLat, String endLng, String endLat) {
+        OpenRouteCalcDTO dto = new OpenRouteCalcDTO();
+        dto.setStartLng(startLng);
+        dto.setStartLat(startLat);
+        dto.setEndLng(endLng);
+        dto.setEndLat(endLat);
+        return dto;
+    }
+}
@@ -4,6 +4,7 @@ import com.diligrp.rider.dto.DeliveryPricingConfigDTO;
 import com.diligrp.rider.dto.DeliveryPricingRuleDTO;
 import com.diligrp.rider.dto.DeliveryFeeCalcDTO;
 import com.diligrp.rider.service.CityService;
+import com.diligrp.rider.service.amap.AmapRouteClient;
 import com.diligrp.rider.util.GeoUtil;
 import com.diligrp.rider.vo.DeliveryFeeResultVO;
 import org.junit.jupiter.api.Test;
@@ -14,13 +15,19 @@ import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
  
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
  
 class DeliveryFeeServiceImplTest {
  
-    private final DeliveryFeeServiceImpl service = new DeliveryFeeServiceImpl(mock(CityService.class));
+    private final AmapRouteClient amapRouteClient = mock(AmapRouteClient.class);
+    private final DeliveryFeeServiceImpl service = new DeliveryFeeServiceImpl(mock(CityService.class), amapRouteClient);
  
     @Test
     void shouldApplyMinFee() {
@@ -126,6 +133,52 @@ class DeliveryFeeServiceImplTest {
         assertEquals(new BigDecimal("2.50"), result.getTotalFee());
     }
  
+    @Test
+    void shouldUseAmapDurationWhenAvailable() {
+        DeliveryPricingConfigDTO pricingConfig = defaultPricingConfig();
+        pricingConfig.getType6().setDistanceSwitch(0);
+        pricingConfig.getType6().setWeightSwitch(0);
+
+        DeliveryFeeCalcDTO calc = baseCalc();
+        calc.setEndLat("31.2574");
+        calc.setEndLng("121.4737");
+        when(amapRouteClient.getElectrobikeDurationMinutes(
+                calc.getStartLng(), calc.getStartLat(), calc.getEndLng(), calc.getEndLat()))
+                .thenReturn(Optional.of(18));
+
+        DeliveryFeeResultVO result = service.calcFeeByConfig(pricingConfig, calc);
+
+        assertEquals(18, result.getEstimatedMinutes());
+    }
+
+    @Test
+    void shouldFallbackToFormulaWhenAmapEmpty() {
+        DeliveryPricingConfigDTO pricingConfig = defaultPricingConfig();
+        pricingConfig.getType6().setDistanceSwitch(0);
+        pricingConfig.getType6().setWeightSwitch(0);
+
+        when(amapRouteClient.getElectrobikeDurationMinutes(any(), any(), any(), any()))
+                .thenReturn(Optional.empty());
+
+        DeliveryFeeResultVO result = service.calcFeeByConfig(pricingConfig, baseCalc());
+
+        // distanceKm=0 时低于 distance_basic=3，应取基础时长 distance_basic_time=30
+        assertEquals(30, result.getEstimatedMinutes());
+    }
+
+    @Test
+    void shouldNotCallAmapForFixedFee() {
+        DeliveryPricingConfigDTO pricingConfig = defaultPricingConfig();
+        pricingConfig.getType6().setFeeMode(1);
+        pricingConfig.getType6().setFixMoney(new BigDecimal("8.00"));
+
+        DeliveryFeeResultVO result = service.calcFeeByConfig(pricingConfig, baseCalc());
+
+        assertEquals(new BigDecimal("8.00"), result.getTotalFee());
+        assertEquals(30, result.getEstimatedMinutes());
+        verify(amapRouteClient, never()).getElectrobikeDurationMinutes(any(), any(), any(), any());
+    }
+
     private DeliveryPricingConfigDTO defaultPricingConfig() {
         DeliveryPricingConfigDTO config = new DeliveryPricingConfigDTO();
         config.setType(Arrays.asList(6));