package com.xiaopeng.map.utils;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.xiaopeng.api.dto.operation.LonLatDto;
|
import com.xiaopeng.api.vo.map.PointByIpVo;
|
import com.xiaopeng.common.core.exception.ServiceException;
|
import com.xiaopeng.common.core.utils.HttpUtils;
|
import com.xiaopeng.map.constant.I18nKeyConstant;
|
import lombok.extern.slf4j.Slf4j;
|
import okhttp3.OkHttpClient;
|
import okhttp3.Request;
|
import okhttp3.Response;
|
import org.springframework.beans.factory.annotation.Value;
|
|
import java.io.IOException;
|
import java.util.HashMap;
|
import java.util.Map;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* 高德地图步行导航工具类
|
*/
|
@Slf4j
|
public class AmapWalkingRouteUtil {
|
|
// 高德地图Web服务API配置
|
private static final String AMAP_API_BASE_URL = "https://restapi.amap.com/v3/direction/walking";
|
private static final String AMAP_GEOCODING_URL = "https://restapi.amap.com/v3/geocode/geo";
|
// 高德API基础URL
|
private static final String IP_API_URL = "https://restapi.amap.com/v3/ip";
|
private static final String GEOCODE_API_URL = "https://restapi.amap.com/v3/geocode/geo";
|
|
|
// HTTP客户端
|
private final OkHttpClient httpClient;
|
private final ObjectMapper objectMapper;
|
|
|
// @Value("${map.apikey}")
|
private static String apiKey="66ae577f63898dae3016d599fda57221";
|
|
/**
|
* IP定位
|
*/
|
public static PointByIpVo ipLocation(String ip) throws IOException {
|
PointByIpVo pointByIpVo = new PointByIpVo();
|
StringBuilder urlBuilder = new StringBuilder(IP_API_URL)
|
.append("?key=").append(apiKey)
|
.append("&output=json");
|
|
if (ip != null && !ip.trim().isEmpty()) {
|
urlBuilder.append("&ip=").append(ip);
|
}
|
|
String response = HttpUtils.sendGet(urlBuilder.toString());
|
JSONObject jsonObject = JSONObject.parseObject(response);
|
|
// 城市名称
|
String city = jsonObject.getString("city");
|
String province = jsonObject.getString("province");
|
if(("局域网").equals(province)){
|
pointByIpVo.setCity("成都市");
|
LonLatDto lonLatDto = new LonLatDto(104.07, 30.660);
|
pointByIpVo.setPoint(lonLatDto);
|
pointByIpVo.setAdcode("510100");
|
return pointByIpVo;
|
}
|
String adcode = jsonObject.getString("adcode");
|
if (city == null || city.trim().isEmpty() || "[]".equals(city)) {
|
// 直辖市：adcode前两位是11,12,31,50
|
if (adcode != null) {
|
String prefix = adcode.substring(0, 2);
|
if ("11".equals(prefix)) {
|
city = "北京市";
|
}
|
if ("12".equals(prefix)) {
|
city = "天津市";
|
}
|
if ("31".equals(prefix)) {
|
city = "上海市";
|
}
|
if ("50".equals(prefix)) {
|
city = "重庆市";
|
}
|
// 如果没有city但有province，使用省份
|
city = province;
|
}
|
}
|
|
LonLatDto lonLatDto = geocodeCity(city);
|
pointByIpVo.setCity(city);
|
pointByIpVo.setPoint(lonLatDto);
|
pointByIpVo.setAdcode(adcode);
|
return pointByIpVo;
|
|
}
|
|
private static LonLatDto geocodeCity(String cityName) throws IOException {
|
String url = GEOCODE_API_URL + "?key=" +apiKey + "&address=" + cityName + "&output=json&city=" + cityName;
|
String response = HttpUtils.sendGet(url);
|
System.out.println(response);
|
JSONObject jsonObject = JSONObject.parseObject(response);
|
// 获取geocodes数组
|
JSONArray geocodes = jsonObject.getJSONArray("geocodes");
|
if (geocodes == null || geocodes.isEmpty()) {
|
return null;
|
}
|
|
// 取第一个geocode
|
JSONObject firstGeocode = geocodes.getJSONObject(0);
|
|
// 获取location字段
|
String lonLat = firstGeocode.getString("location");
|
String[] lonLatArray = lonLat.split(",");
|
double longitude = Double.parseDouble(lonLatArray[0]);
|
double latitude = Double.parseDouble(lonLatArray[1]);
|
return new LonLatDto(longitude, latitude);
|
|
}
|
public static void main (String[]args) throws IOException {
|
geocodeCity("凉山彝族自治州");
|
|
}
|
|
|
/**
|
* 构造函数
|
* @param apiKey 高德地图API Key
|
*/
|
public AmapWalkingRouteUtil(String apiKey) {
|
this.apiKey = apiKey;
|
this.httpClient = new OkHttpClient.Builder()
|
.connectTimeout(10, TimeUnit.SECONDS)
|
.readTimeout(10, TimeUnit.SECONDS)
|
.writeTimeout(10, TimeUnit.SECONDS)
|
.build();
|
this.objectMapper = new ObjectMapper();
|
}
|
|
/**
|
* 位置坐标类
|
*/
|
public static class Location {
|
private final double longitude; // 经度
|
private final double latitude; // 纬度
|
|
public Location(double longitude, double latitude) {
|
this.longitude = longitude;
|
this.latitude = latitude;
|
}
|
|
public double getLongitude() {
|
return longitude;
|
}
|
|
public double getLatitude() {
|
return latitude;
|
}
|
|
@Override
|
public String toString() {
|
return String.format("%.6f,%.6f", longitude, latitude);
|
}
|
}
|
|
/**
|
* 步行路线结果类
|
*/
|
public static class WalkingRouteResult {
|
private int duration; // 步行时间（秒）
|
private int distance; // 步行距离（米）
|
private String origin; // 起点地址
|
private String destination; // 终点地址
|
private boolean success; // 是否成功
|
private String message; // 返回信息
|
|
// getters and setters
|
public int getDuration() {
|
return duration;
|
}
|
|
public void setDuration(int duration) {
|
this.duration = duration;
|
}
|
|
public int getDistance() {
|
return distance;
|
}
|
|
public void setDistance(int distance) {
|
this.distance = distance;
|
}
|
|
public String getOrigin() {
|
return origin;
|
}
|
|
public void setOrigin(String origin) {
|
this.origin = origin;
|
}
|
|
public String getDestination() {
|
return destination;
|
}
|
|
public void setDestination(String destination) {
|
this.destination = destination;
|
}
|
|
public boolean isSuccess() {
|
return success;
|
}
|
|
public void setSuccess(boolean success) {
|
this.success = success;
|
}
|
|
public String getMessage() {
|
return message;
|
}
|
|
public void setMessage(String message) {
|
this.message = message;
|
}
|
|
/**
|
* 获取格式化的步行时间
|
* @return 格式化的时间字符串（如：15分钟30秒）
|
*/
|
public String getFormattedDuration() {
|
|
int seconds = duration;
|
int minutes = seconds / 60;
|
seconds = seconds % 60;
|
return String.format("%d分%d秒", minutes, seconds);
|
}
|
|
/**
|
* 获取格式化的步行距离
|
* @return 格式化的距离字符串（如：1.2公里）
|
*/
|
public String getFormattedDistance() {
|
if (distance >= 1000) {
|
double km = distance / 1000.0;
|
return String.format("%.1f公里", km);
|
} else {
|
return String.format("%d米", distance);
|
}
|
}
|
}
|
|
/**
|
* 根据地址获取经纬度坐标
|
* @param address 地址信息
|
* @return 经纬度坐标
|
*/
|
public Location getLocationByAddress (String address) throws IOException {
|
Map<String, String> params = new HashMap<>();
|
params.put("key", apiKey);
|
params.put("address", address);
|
|
String url = buildUrl(AMAP_GEOCODING_URL, params);
|
Request request = new Request.Builder().url(url).build();
|
|
try (Response response = httpClient.newCall(request).execute()) {
|
if (!response.isSuccessful()) {
|
throw new IOException("请求失败: " + response);
|
}
|
|
String responseBody = response.body().string();
|
JsonNode rootNode = objectMapper.readTree(responseBody);
|
|
if ("1".equals(rootNode.get("status").asText())) {
|
JsonNode geocodes = rootNode.get("geocodes");
|
if (geocodes != null && geocodes.size() > 0) {
|
String locationStr = geocodes.get(0).get("location").asText();
|
String[] locationArray = locationStr.split(",");
|
double longitude = Double.parseDouble(locationArray[0]);
|
double latitude = Double.parseDouble(locationArray[1]);
|
return new Location(longitude, latitude);
|
}
|
}
|
|
throw new IOException("地址解析失败: " + rootNode.get("info").asText());
|
}
|
}
|
|
/**
|
* 获取步行路线和时间
|
* @param origin 起点坐标
|
* @param destination 终点坐标
|
* @return 步行路线结果
|
*/
|
public WalkingRouteResult getWalkingRoute (Location origin, Location destination){
|
WalkingRouteResult result = new WalkingRouteResult();
|
|
try {
|
Map<String, String> params = new HashMap<>();
|
params.put("key", apiKey);
|
params.put("origin", origin.toString());
|
params.put("destination", destination.toString());
|
|
String url = buildUrl(AMAP_API_BASE_URL, params);
|
Request request = new Request.Builder().url(url).build();
|
|
try (Response response = httpClient.newCall(request).execute()) {
|
if (!response.isSuccessful()) {
|
result.setSuccess(false);
|
result.setMessage("HTTP请求失败: " + response.code());
|
return result;
|
}
|
|
String responseBody = response.body().string();
|
JsonNode rootNode = objectMapper.readTree(responseBody);
|
|
String status = rootNode.get("status").asText();
|
String info = rootNode.get("info").asText();
|
|
if ("1".equals(status)) {
|
JsonNode route = rootNode.get("route");
|
JsonNode paths = route.get("paths");
|
|
if (paths != null && paths.size() > 0) {
|
JsonNode firstPath = paths.get(0);
|
int duration = firstPath.get("duration").asInt();
|
int distance = firstPath.get("distance").asInt();
|
|
result.setDuration(duration);
|
result.setDistance(distance);
|
result.setSuccess(true);
|
result.setMessage("成功获取步行路线");
|
|
// 尝试获取地址信息
|
result.setOrigin(getAddressByLocation(origin));
|
result.setDestination(getAddressByLocation(destination));
|
|
} else {
|
result.setSuccess(false);
|
result.setMessage("未找到步行路线");
|
log.info("未找到步行路线");
|
throw new ServiceException("未找到步行路线", I18nKeyConstant.NO_WALKING_ROUTE_FOUND);
|
}
|
} else {
|
result.setSuccess(false);
|
result.setMessage("API返回错误: " + info);
|
log.info("API返回错误" + info);
|
throw new ServiceException("未找到步行路线", I18nKeyConstant.NO_WALKING_ROUTE_FOUND);
|
}
|
}
|
} catch (Exception e) {
|
result.setSuccess(false);
|
result.setMessage("获取步行路线失败: " + e.getMessage());
|
log.info("获取步行路线失败" + e.getMessage());
|
throw new ServiceException("未找到步行路线", I18nKeyConstant.NO_WALKING_ROUTE_FOUND);
|
}
|
|
return result;
|
}
|
|
/**
|
* 根据经纬度获取地址（逆地理编码）
|
* @param location 经纬度坐标
|
* @return 地址信息
|
*/
|
private String getAddressByLocation (Location location){
|
try {
|
Map<String, String> params = new HashMap<>();
|
params.put("key", apiKey);
|
params.put("location", location.toString());
|
|
String url = buildUrl("https://restapi.amap.com/v3/geocode/regeo", params);
|
Request request = new Request.Builder().url(url).build();
|
|
try (Response response = httpClient.newCall(request).execute()) {
|
if (response.isSuccessful()) {
|
String responseBody = response.body().string();
|
JsonNode rootNode = objectMapper.readTree(responseBody);
|
|
if ("1".equals(rootNode.get("status").asText())) {
|
JsonNode regeocode = rootNode.get("regeocode");
|
if (regeocode != null) {
|
return regeocode.get("formatted_address").asText();
|
}
|
}
|
}
|
}
|
} catch (Exception e) {
|
// 地址解析失败时返回坐标
|
}
|
return location.toString();
|
}
|
|
/**
|
* 构建带参数的URL
|
* @param baseUrl 基础URL
|
* @param params 参数Map
|
* @return 完整的URL
|
*/
|
private String buildUrl (String baseUrl, Map < String, String > params){
|
StringBuilder urlBuilder = new StringBuilder(baseUrl).append("?");
|
params.forEach((key, value) -> {
|
urlBuilder.append(key).append("=").append(value).append("&");
|
});
|
// 删除最后一个&
|
urlBuilder.deleteCharAt(urlBuilder.length() - 1);
|
return urlBuilder.toString();
|
}
|
|
/**
|
* 计算两点间的直线距离（仅供参考，不是实际步行距离）
|
* @param loc1 坐标1
|
* @param loc2 坐标2
|
* @return 直线距离（米）
|
*/
|
public static double calculateStraightDistance (Location loc1, Location loc2){
|
double earthRadius = 6371000; // 地球半径（米）
|
double lat1 = Math.toRadians(loc1.getLatitude());
|
double lat2 = Math.toRadians(loc2.getLatitude());
|
double deltaLat = Math.toRadians(loc2.getLatitude() - loc1.getLatitude());
|
double deltaLon = Math.toRadians(loc2.getLongitude() - loc1.getLongitude());
|
|
double a = Math.sin(deltaLat / 2) * Math.sin(deltaLat / 2) +
|
Math.cos(lat1) * Math.cos(lat2) *
|
Math.sin(deltaLon / 2) * Math.sin(deltaLon / 2);
|
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
|
|
return earthRadius * c;
|
}
|
|
|
}
|
