Java坐标转换全攻略：3大实现路径让位置服务不再难，后端开发必备技能！

2025-12-21 / 2025-12-21 / Note

大家好，我是你们的后端技术伙伴。今天我们来聊聊一个在位置服务开发中经常遇到的问题——坐标转换。无论你是做LBS应用、物流系统还是出行服务，坐标转换都是绕不开的技术点。

你是否遇到过这样的困扰：

用户在APP上看到的位置和后台系统记录的不一致？
不同地图服务商的坐标系不统一导致显示偏差？
想要做坐标转换但不知道该选哪种实现方式？
自己写算法总觉得精度不够或者性能不佳？

别急，今天这篇文章就带你彻底搞懂Java中的坐标转换，从在线API调用到纯Java代码实现，一网打尽所有实现路径！

坐标转换基础概念科普

在深入实现之前，我们先来了解一下坐标转换的基础知识，这样后面的内容会更容易理解。

常见的坐标系类型

WGS84坐标系：国际通用的地理坐标系，GPS设备获取的坐标就是这个坐标系
GCJ02坐标系：中国国家测绘局制定的坐标系，也叫"火星坐标系"
BD09坐标系：百度地图使用的坐标系，在GCJ02基础上再次加密

为什么需要坐标转换？

由于国家安全考虑，中国境内的地图服务都需要使用加密后的坐标系。这就导致了不同地图服务商之间的坐标不能直接使用，需要进行转换。

坐标转换的基本原理

坐标转换本质上是数学变换，通过特定的算法将一种坐标系下的经纬度转换为另一种坐标系下的经纬度。不同的转换算法精度和复杂度也不同。

实现路径一：在线API调用

最简单的坐标转换方式就是调用第三方提供的在线API服务。这种方式实现简单，但依赖网络和第三方服务。

通用HTTP API调用实现

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import com.fasterxml.jackson.databind.ObjectMapper;

public class OnlineCoordinateConverter {
    
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    /**
     * 通用坐标转换方法
     * @param lat 纬度
     * @param lng 经度
     * @param fromType 源坐标系类型
     * @param toType 目标坐标系类型
     * @return 转换后的坐标
     */
    public static Coordinate convert(double lat, double lng, 
                                   CoordinateType fromType, CoordinateType toType) {
        try {
            // 构造API请求URL
            String apiUrl = buildApiUrl(lat, lng, fromType, toType);
            
            // 发送HTTP请求
            String response = sendHttpGetRequest(apiUrl);
            
            // 解析响应结果
            return parseResponse(response, toType);
        } catch (Exception e) {
            throw new CoordinateConversionException("坐标转换失败", e);
        }
    }
    
    /**
     * 构造API请求URL
     */
    private static String buildApiUrl(double lat, double lng, 
                                    CoordinateType fromType, CoordinateType toType) {
        // 这里以一个假想的通用坐标转换API为例
        return String.format(
            "https://api.coordtransform.com/convert?lat=%f&lng=%f&from=%s&to=%s&key=YOUR_API_KEY",
            lat, lng, fromType.getCode(), toType.getCode());
    }
    
    /**
     * 发送HTTP GET请求
     */
    private static String sendHttpGetRequest(String urlString) throws Exception {
        URL url = new URL(urlString);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("User-Agent", "Java Coordinate Converter");
        connection.setConnectTimeout(5000);
        connection.setReadTimeout(5000);
        
        int responseCode = connection.getResponseCode();
        if (responseCode != 200) {
            throw new RuntimeException("HTTP请求失败，状态码: " + responseCode);
        }
        
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
        StringBuilder response = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();
        
        return response.toString();
    }
    
    /**
     * 解析API响应
     */
    private static Coordinate parseResponse(String response, CoordinateType targetType) 
            throws Exception {
        // 假设API返回JSON格式
        // {"status":"ok","result":{"lat":39.9042,"lng":116.4074}}
        CoordinateResponse coordResponse = objectMapper.readValue(response, 
                                                                 CoordinateResponse.class);
        if ("ok".equals(coordResponse.getStatus())) {
            return new Coordinate(coordResponse.getResult().getLat(), 
                                coordResponse.getResult().getLng(), targetType);
        } else {
            throw new CoordinateConversionException("API返回错误: " + coordResponse.getStatus());
        }
    }
    
    // 相关数据类
    public enum CoordinateType {
        WGS84("wgs84"), GCJ02("gcj02"), BD09("bd09");
        
        private final String code;
        
        CoordinateType(String code) {
            this.code = code;
        }
        
        public String getCode() {
            return code;
        }
    }
    
    public static class Coordinate {
        private double lat;
        private double lng;
        private CoordinateType type;
        
        public Coordinate(double lat, double lng, CoordinateType type) {
            this.lat = lat;
            this.lng = lng;
            this.type = type;
        }
        
        // getters and setters
        public double getLat() { return lat; }
        public void setLat(double lat) { this.lat = lat; }
        public double getLng() { return lng; }
        public void setLng(double lng) { this.lng = lng; }
        public CoordinateType getType() { return type; }
        public void setType(CoordinateType type) { this.type = type; }
        
        @Override
        public String toString() {
            return String.format("Coordinate{lat=%f, lng=%f, type=%s}", lat, lng, type);
        }
    }
    
    private static class CoordinateResponse {
        private String status;
        private Result result;
        
        // getters and setters
        public String getStatus() { return status; }
        public void setStatus(String status) { this.status = status; }
        public Result getResult() { return result; }
        public void setResult(Result result) { this.result = result; }
    }
    
    private static class Result {
        private double lat;
        private double lng;
        
        // getters and setters
        public double getLat() { return lat; }
        public void setLat(double lat) { this.lat = lat; }
        public double getLng() { return lng; }
        public void setLng(double lng) { this.lng = lng; }
    }
    
    public static class CoordinateConversionException extends RuntimeException {
        public CoordinateConversionException(String message) {
            super(message);
        }
        
        public CoordinateConversionException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}

使用示例

public class OnlineConverterExample {
    public static void main(String[] args) {
        try {
            // 将WGS84坐标转换为GCJ02坐标
            OnlineCoordinateConverter.Coordinate result = OnlineCoordinateConverter.convert(
                39.9042, 116.4074, 
                OnlineCoordinateConverter.CoordinateType.WGS84,
                OnlineCoordinateConverter.CoordinateType.GCJ02);
            
            System.out.println("转换结果: " + result);
        } catch (Exception e) {
            System.err.println("转换失败: " + e.getMessage());
        }
    }
}

这种方式的优点是实现简单，缺点是依赖网络和第三方服务，可能存在延迟和稳定性问题。

实现路径二：百度地图API集成

百度地图提供了丰富的API服务，包括坐标转换功能。下面我们来看看如何集成百度地图API实现坐标转换。

百度地图坐标转换API集成

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class BaiduCoordinateConverter {
    
    private static final String BAIDU_API_KEY = "YOUR_BAIDU_API_KEY";
    private static final String BAIDU_COORD_CONVERT_URL = 
        "http://api.map.baidu.com/geoconv/v1/?";
    
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    /**
     * 百度地图坐标转换
     * @param coords 坐标点列表，格式：经度,纬度;经度,纬度
     * @param fromType 源坐标类型
     * @param toType 目标坐标类型
     * @return 转换后的坐标列表
     */
    public static Coordinate[] convertCoordinates(String coords, 
                                                BaiduCoordType fromType, 
                                                BaiduCoordType toType) {
        try {
            // 构造请求参数
            String params = buildParams(coords, fromType, toType);
            String requestUrl = BAIDU_COORD_CONVERT_URL + params;
            
            // 发送请求
            String response = sendHttpGetRequest(requestUrl);
            
            // 解析响应
            return parseBaiduResponse(response);
        } catch (Exception e) {
            throw new CoordinateConversionException("百度坐标转换失败", e);
        }
    }
    
    /**
     * 单个坐标转换
     */
    public static Coordinate convert(double lat, double lng, 
                                   BaiduCoordType fromType, BaiduCoordType toType) {
        String coords = lng + "," + lat;
        Coordinate[] results = convertCoordinates(coords, fromType, toType);
        return results.length > 0 ? results[0] : null;
    }
    
    /**
     * 构造请求参数
     */
    private static String buildParams(String coords, BaiduCoordType fromType, 
                                    BaiduCoordType toType) throws Exception {
        StringBuilder params = new StringBuilder();
        params.append("coords=").append(URLEncoder.encode(coords, "UTF-8"));
        params.append("&from=").append(fromType.getCode());
        params.append("&to=").append(toType.getCode());
        params.append("&ak=").append(BAIDU_API_KEY);
        return params.toString();
    }
    
    /**
     * 发送HTTP请求
     */
    private static String sendHttpGetRequest(String urlString) throws Exception {
        URL url = new URL(urlString);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("User-Agent", "Baidu Coordinate Converter");
        connection.setConnectTimeout(5000);
        connection.setReadTimeout(5000);
        
        int responseCode = connection.getResponseCode();
        if (responseCode != 200) {
            throw new RuntimeException("HTTP请求失败，状态码: " + responseCode);
        }
        
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
        StringBuilder response = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();
        
        return response.toString();
    }
    
    /**
     * 解析百度API响应
     */
    private static Coordinate[] parseBaiduResponse(String response) throws Exception {
        JsonNode rootNode = objectMapper.readTree(response);
        int status = rootNode.get("status").asInt();
        
        if (status != 0) {
            String message = rootNode.has("message") ? 
                rootNode.get("message").asText() : "未知错误";
            throw new CoordinateConversionException("百度API错误: " + message);
        }
        
        JsonNode resultNode = rootNode.get("result");
        if (resultNode.isArray()) {
            Coordinate[] coordinates = new Coordinate[resultNode.size()];
            for (int i = 0; i < resultNode.size(); i++) {
                JsonNode item = resultNode.get(i);
                double x = item.get("x").asDouble();
                double y = item.get("y").asDouble();
                coordinates[i] = new Coordinate(y, x); // 注意：百度返回的是lng,lat顺序
            }
            return coordinates;
        }
        
        return new Coordinate[0];
    }
    
    // 百度坐标类型枚举
    public enum BaiduCoordType {
        GPS(1),       // GPS设备获取的坐标
        GOOGLE(2),    // Google地图坐标
        SOSO(3),      // 搜搜地图坐标
        MAPBAR(4),    // 图吧地图坐标
        DITU(5),      // 地图坐标
        GAODE(6),     // 高德坐标
        GPS_ENCRYPT(7); // 加密后的GPS坐标
        
        private final int code;
        
        BaiduCoordType(int code) {
            this.code = code;
        }
        
        public int getCode() {
            return code;
        }
    }
    
    public static class Coordinate {
        private double lat;
        private double lng;
        
        public Coordinate(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
        
        // getters and setters
        public double getLat() { return lat; }
        public void setLat(double lat) { this.lat = lat; }
        public double getLng() { return lng; }
        public void setLng(double lng) { this.lng = lng; }
        
        @Override
        public String toString() {
            return String.format("Coordinate{lat=%f, lng=%f}", lat, lng);
        }
    }
    
    public static class CoordinateConversionException extends RuntimeException {
        public CoordinateConversionException(String message) {
            super(message);
        }
        
        public CoordinateConversionException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}

百度地图API使用示例

public class BaiduConverterExample {
    public static void main(String[] args) {
        try {
            // 将GPS坐标转换为百度坐标
            BaiduCoordinateConverter.Coordinate result = BaiduCoordinateConverter.convert(
                39.9042, 116.4074, 
                BaiduCoordinateConverter.BaiduCoordType.GPS,
                BaiduCoordinateConverter.BaiduCoordType.GAODE);
            
            System.out.println("百度转换结果: " + result);
            
            // 批量转换
            String coords = "116.4074,39.9042;116.3974,39.9142";
            BaiduCoordinateConverter.Coordinate[] results = 
                BaiduCoordinateConverter.convertCoordinates(
                    coords,
                    BaiduCoordinateConverter.BaiduCoordType.GPS,
                    BaiduCoordinateConverter.BaiduCoordType.GAODE);
            
            for (int i = 0; i < results.length; i++) {
                System.out.println("第" + (i+1) + "个坐标: " + results[i]);
            }
        } catch (Exception e) {
            System.err.println("转换失败: " + e.getMessage());
        }
    }
}

百度地图API集成注意事项

API密钥申请：需要在百度地图开放平台申请API密钥
配额限制：免费用户有调用次数限制
坐标顺序：百度API返回的坐标是lng,lat顺序，注意不要搞反
错误处理：要妥善处理API返回的错误码

实现路径三：高德地图API集成

高德地图也是国内主流的地图服务商之一，同样提供了坐标转换API。下面我们来看看如何集成高德地图API。

高德地图坐标转换API集成

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class AMapCoordinateConverter {
    
    private static final String AMAP_API_KEY = "YOUR_AMAP_API_KEY";
    private static final String AMAP_COORD_CONVERT_URL = 
        "https://restapi.amap.com/v3/assistant/coordinate/convert?";
    
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    /**
     * 高德地图坐标转换
     * @param locations 坐标点列表，格式：经度,纬度|经度,纬度
     * @param coordsys 源坐标系
     * @return 转换后的坐标
     */
    public static Coordinate convertCoordinates(String locations, 
                                              AMapCoordSys coordsys) {
        try {
            // 构造请求参数
            String params = buildParams(locations, coordsys);
            String requestUrl = AMAP_COORD_CONVERT_URL + params;
            
            // 发送请求
            String response = sendHttpGetRequest(requestUrl);
            
            // 解析响应
            return parseAMapResponse(response);
        } catch (Exception e) {
            throw new CoordinateConversionException("高德坐标转换失败", e);
        }
    }
    
    /**
     * 单个坐标转换
     */
    public static Coordinate convert(double lat, double lng, AMapCoordSys coordsys) {
        String locations = lng + "," + lat;
        return convertCoordinates(locations, coordsys);
    }
    
    /**
     * 构造请求参数
     */
    private static String buildParams(String locations, AMapCoordSys coordsys) 
            throws Exception {
        StringBuilder params = new StringBuilder();
        params.append("locations=").append(URLEncoder.encode(locations, "UTF-8"));
        params.append("&coordsys=").append(coordsys.getCode());
        params.append("&output=json");
        params.append("&key=").append(AMAP_API_KEY);
        return params.toString();
    }
    
    /**
     * 发送HTTP请求
     */
    private static String sendHttpGetRequest(String urlString) throws Exception {
        URL url = new URL(urlString);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("User-Agent", "AMap Coordinate Converter");
        connection.setConnectTimeout(5000);
        connection.setReadTimeout(5000);
        
        int responseCode = connection.getResponseCode();
        if (responseCode != 200) {
            throw new RuntimeException("HTTP请求失败，状态码: " + responseCode);
        }
        
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
        StringBuilder response = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();
        
        return response.toString();
    }
    
    /**
     * 解析高德API响应
     */
    private static Coordinate parseAMapResponse(String response) throws Exception {
        JsonNode rootNode = objectMapper.readTree(response);
        String status = rootNode.get("status").asText();
        
        if (!"1".equals(status)) {
            String info = rootNode.has("info") ? rootNode.get("info").asText() : "未知错误";
            throw new CoordinateConversionException("高德API错误: " + info);
        }
        
        String locations = rootNode.get("locations").asText();
        if (locations != null && !locations.isEmpty()) {
            String[] coords = locations.split(",");
            if (coords.length >= 2) {
                double lng = Double.parseDouble(coords[0]);
                double lat = Double.parseDouble(coords[1]);
                return new Coordinate(lat, lng);
            }
        }
        
        throw new CoordinateConversionException("解析坐标失败");
    }
    
    // 高德坐标系枚举
    public enum AMapCoordSys {
        GPS("gps"),           // GPS坐标
        AMAP("autonavi"),     // 高德坐标（火星坐标）
        BAIDU("baidu"),       // 百度坐标
        MAPBAR("mapbar"),     // 图吧坐标
        GOOGLE("google");     // Google坐标
        
        private final String code;
        
        AMapCoordSys(String code) {
            this.code = code;
        }
        
        public String getCode() {
            return code;
        }
    }
    
    public static class Coordinate {
        private double lat;
        private double lng;
        
        public Coordinate(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
        
        // getters and setters
        public double getLat() { return lat; }
        public void setLat(double lat) { this.lat = lat; }
        public double getLng() { return lng; }
        public void setLng(double lng) { this.lng = lng; }
        
        @Override
        public String toString() {
            return String.format("Coordinate{lat=%f, lng=%f}", lat, lng);
        }
    }
    
    public static class CoordinateConversionException extends RuntimeException {
        public CoordinateConversionException(String message) {
            super(message);
        }
        
        public CoordinateConversionException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}

高德地图API使用示例

public class AMapConverterExample {
    public static void main(String[] args) {
        try {
            // 将GPS坐标转换为高德坐标
            AMapCoordinateConverter.Coordinate result = AMapCoordinateConverter.convert(
                39.9042, 116.4074, 
                AMapCoordinateConverter.AMapCoordSys.GPS);
            
            System.out.println("高德转换结果: " + result);
            
            // 批量转换
            String locations = "116.4074,39.9042|116.3974,39.9142";
            AMapCoordinateConverter.Coordinate batchResult = 
                AMapCoordinateConverter.convertCoordinates(
                    locations,
                    AMapCoordinateConverter.AMapCoordSys.GPS);
            
            System.out.println("批量转换结果: " + batchResult);
        } catch (Exception e) {
            System.err.println("转换失败: " + e.getMessage());
        }
    }
}

高德地图API集成注意事项

API密钥申请：需要在高德地图开放平台申请API密钥
调用限制：注意API的调用频率限制
坐标格式：高德API使用lng,lat格式，与百度一致
批量处理：高德API支持批量坐标转换，可以提高效率

实现路径四：纯Java代码实现

对于一些对性能和稳定性要求较高的场景，我们可以选择使用纯Java代码实现坐标转换算法，这样不依赖外部服务，完全自主可控。

WGS84到GCJ02坐标转换算法实现

public class PureJavaCoordinateConverter {
    
    // 地球半径（米）
    private static final double EARTH_RADIUS = 6378137.0;
    
    // 圆周率
    private static final double PI = 3.1415926535897932384626;
    
    // Krasovsky 1940椭球参数
    private static final double A = 6378245.0;      // 长半轴
    private static final double EE = 0.00669342162296594323; // 扁率
    
    /**
     * WGS84坐标转换为GCJ02坐标（火星坐标）
     * @param wgsLat WGS84纬度
     * @param wgsLng WGS84经度
     * @return GCJ02坐标
     */
    public static Coordinate wgs84ToGcj02(double wgsLat, double wgsLng) {
        if (outOfChina(wgsLat, wgsLng)) {
            return new Coordinate(wgsLat, wgsLng);
        }
        
        double[] delta = delta(wgsLat, wgsLng);
        return new Coordinate(wgsLat + delta[0], wgsLng + delta[1]);
    }
    
    /**
     * GCJ02坐标转换为WGS84坐标
     * @param gcjLat GCJ02纬度
     * @param gcjLng GCJ02经度
     * @return WGS84坐标
     */
    public static Coordinate gcj02ToWgs84(double gcjLat, double gcjLng) {
        if (outOfChina(gcjLat, gcjLng)) {
            return new Coordinate(gcjLat, gcjLng);
        }
        
        double[] delta = delta(gcjLat, gcjLng);
        return new Coordinate(gcjLat - delta[0], gcjLng - delta[1]);
    }
    
    /**
     * GCJ02坐标转换为BD09坐标（百度坐标）
     * @param gcjLat GCJ02纬度
     * @param gcjLng GCJ02经度
     * @return BD09坐标
     */
    public static Coordinate gcj02ToBd09(double gcjLat, double gcjLng) {
        double x = gcjLng, y = gcjLat;
        double z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * PI * 3000.0 / 180.0);
        double theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * PI * 3000.0 / 180.0);
        double bdLng = z * Math.cos(theta) + 0.0065;
        double bdLat = z * Math.sin(theta) + 0.006;
        return new Coordinate(bdLat, bdLng);
    }
    
    /**
     * BD09坐标转换为GCJ02坐标
     * @param bdLat BD09纬度
     * @param bdLng BD09经度
     * @return GCJ02坐标
     */
    public static Coordinate bd09ToGcj02(double bdLat, double bdLng) {
        double x = bdLng - 0.0065, y = bdLat - 0.006;
        double z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * PI * 3000.0 / 180.0);
        double theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * PI * 3000.0 / 180.0);
        double gcjLng = z * Math.cos(theta);
        double gcjLat = z * Math.sin(theta);
        return new Coordinate(gcjLat, gcjLng);
    }
    
    /**
     * 计算偏移量
     */
    private static double[] delta(double lat, double lng) {
        double dLat = transformLat(lng - 105.0, lat - 35.0);
        double dLng = transformLng(lng - 105.0, lat - 35.0);
        
        double radLat = lat / 180.0 * PI;
        double magic = Math.sin(radLat);
        magic = 1 - EE * magic * magic;
        double sqrtMagic = Math.sqrt(magic);
        
        dLat = (dLat * 180.0) / ((A * (1 - EE)) / (magic * sqrtMagic) * PI);
        dLng = (dLng * 180.0) / (A / sqrtMagic * Math.cos(radLat) * PI);
        
        return new double[]{dLat, dLng};
    }
    
    /**
     * 转换纬度
     */
    private static double transformLat(double x, double y) {
        double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
        ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
        ret += (20.0 * Math.sin(y * PI) + 40.0 * Math.sin(y / 3.0 * PI)) * 2.0 / 3.0;
        ret += (160.0 * Math.sin(y / 12.0 * PI) + 320 * Math.sin(y * PI / 30.0)) * 2.0 / 3.0;
        return ret;
    }
    
    /**
     * 转换经度
     */
    private static double transformLng(double x, double y) {
        double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
        ret += (20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0 / 3.0;
        ret += (20.0 * Math.sin(x * PI) + 40.0 * Math.sin(x / 3.0 * PI)) * 2.0 / 3.0;
        ret += (150.0 * Math.sin(x / 12.0 * PI) + 300.0 * Math.sin(x / 30.0 * PI)) * 2.0 / 3.0;
        return ret;
    }
    
    /**
     * 判断坐标是否在中国范围内
     */
    private static boolean outOfChina(double lat, double lng) {
        return (lng < 72.004 || lng > 137.8347) || (lat < 0.8293 || lat > 55.8271);
    }
    
    /**
     * 坐标类
     */
    public static class Coordinate {
        private double lat;
        private double lng;
        
        public Coordinate(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
        
        public double getLat() { return lat; }
        public void setLat(double lat) { this.lat = lat; }
        public double getLng() { return lng; }
        public void setLng(double lng) { this.lng = lng; }
        
        @Override
        public String toString() {
            return String.format("Coordinate{lat=%f, lng=%f}", lat, lng);
        }
    }
    
    /**
     * 批量转换坐标
     */
    public static Coordinate[] batchConvert(Coordinate[] coordinates, 
                                          ConversionType conversionType) {
        Coordinate[] results = new Coordinate[coordinates.length];
        for (int i = 0; i < coordinates.length; i++) {
            Coordinate coord = coordinates[i];
            switch (conversionType) {
                case WGS84_TO_GCJ02:
                    results[i] = wgs84ToGcj02(coord.getLat(), coord.getLng());
                    break;
                case GCJ02_TO_WGS84:
                    results[i] = gcj02ToWgs84(coord.getLat(), coord.getLng());
                    break;
                case GCJ02_TO_BD09:
                    results[i] = gcj02ToBd09(coord.getLat(), coord.getLng());
                    break;
                case BD09_TO_GCJ02:
                    results[i] = bd09ToGcj02(coord.getLat(), coord.getLng());
                    break;
                default:
                    results[i] = new Coordinate(coord.getLat(), coord.getLng());
            }
        }
        return results;
    }
    
    /**
     * 转换类型枚举
     */
    public enum ConversionType {
        WGS84_TO_GCJ02,
        GCJ02_TO_WGS84,
        GCJ02_TO_BD09,
        BD09_TO_GCJ02
    }
}

纯Java实现使用示例

public class PureJavaConverterExample {
    public static void main(String[] args) {
        // WGS84转GCJ02
        PureJavaCoordinateConverter.Coordinate gcj02 = 
            PureJavaCoordinateConverter.wgs84ToGcj02(39.9042, 116.4074);
        System.out.println("WGS84转GCJ02: " + gcj02);
        
        // GCJ02转BD09（百度坐标）
        PureJavaCoordinateConverter.Coordinate bd09 = 
            PureJavaCoordinateConverter.gcj02ToBd09(gcj02.getLat(), gcj02.getLng());
        System.out.println("GCJ02转BD09: " + bd09);
        
        // 批量转换示例
        PureJavaCoordinateConverter.Coordinate[] coordinates = {
            new PureJavaCoordinateConverter.Coordinate(39.9042, 116.4074),
            new PureJavaCoordinateConverter.Coordinate(39.9142, 116.3974),
            new PureJavaCoordinateConverter.Coordinate(39.9242, 116.3874)
        };
        
        PureJavaCoordinateConverter.Coordinate[] results = 
            PureJavaCoordinateConverter.batchConvert(
                coordinates, 
                PureJavaCoordinateConverter.ConversionType.WGS84_TO_GCJ02);
        
        for (int i = 0; i < results.length; i++) {
            System.out.println("第" + (i+1) + "个坐标转换结果: " + results[i]);
        }
    }
}

纯Java实现的优势与局限

优势：

完全自主可控：不依赖外部服务，稳定性高
性能优异：本地计算，响应速度快
无调用限制：不受API调用次数限制
隐私安全：坐标数据不外传

局限：

算法复杂度高：需要理解和维护复杂的数学算法
精度可能略低：相比商业API可能在某些边界情况精度稍低
维护成本：需要跟进算法更新和优化

性能对比与选型建议

为了帮助大家更好地选择合适的坐标转换实现方式，我们来做一下性能对比测试。

性能测试代码

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class PerformanceComparison {
    
    public static void main(String[] args) {
        // 生成测试数据
        List<Coordinate> testData = generateTestData(10000);
        
        // 测试在线API调用（模拟）
        long onlineApiTime = testOnlineApi(testData);
        System.out.println("在线API调用耗时: " + onlineApiTime + "ms");
        
        // 测试纯Java实现
        long pureJavaTime = testPureJava(testData);
        System.out.println("纯Java实现耗时: " + pureJavaTime + "ms");
        
        // 测试百度API调用（模拟）
        long baiduApiTime = testBaiduApi(testData);
        System.out.println("百度API调用耗时: " + baiduApiTime + "ms");
        
        // 测试高德API调用（模拟）
        long amapApiTime = testAmapApi(testData);
        System.out.println("高德API调用耗时: " + amapApiTime + "ms");
        
        // 性能对比分析
        System.out.println("\n=== 性能对比分析 ===");
        System.out.println("纯Java实现比在线API快: " + (onlineApiTime / (double) pureJavaTime) + "倍");
        System.out.println("纯Java实现比百度API快: " + (baiduApiTime / (double) pureJavaTime) + "倍");
        System.out.println("纯Java实现比高德API快: " + (amapApiTime / (double) pureJavaTime) + "倍");
    }
    
    /**
     * 生成测试数据
     */
    private static List<Coordinate> generateTestData(int count) {
        List<Coordinate> coordinates = new ArrayList<>(count);
        Random random = new Random();
        
        for (int i = 0; i < count; i++) {
            // 生成中国范围内的随机坐标
            double lat = 20.0 + random.nextDouble() * 35.0;  // 纬度 20-55
            double lng = 100.0 + random.nextDouble() * 37.0; // 经度 100-137
            coordinates.add(new Coordinate(lat, lng));
        }
        
        return coordinates;
    }
    
    /**
     * 测试在线API调用性能（模拟）
     */
    private static long testOnlineApi(List<Coordinate> testData) {
        long startTime = System.currentTimeMillis();
        
        for (Coordinate coord : testData) {
            // 模拟网络延迟
            try {
                Thread.sleep(1); // 模拟1ms网络延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            
            // 模拟在线API调用
            // OnlineCoordinateConverter.convert(coord.getLat(), coord.getLng(), ...);
        }
        
        return System.currentTimeMillis() - startTime;
    }
    
    /**
     * 测试纯Java实现性能
     */
    private static long testPureJava(List<Coordinate> testData) {
        long startTime = System.currentTimeMillis();
        
        for (Coordinate coord : testData) {
            // 纯Java实现
            PureJavaCoordinateConverter.wgs84ToGcj02(coord.getLat(), coord.getLng());
        }
        
        return System.currentTimeMillis() - startTime;
    }
    
    /**
     * 测试百度API调用性能（模拟）
     */
    private static long testBaiduApi(List<Coordinate> testData) {
        long startTime = System.currentTimeMillis();
        
        for (Coordinate coord : testData) {
            // 模拟网络延迟
            try {
                Thread.sleep(2); // 模拟2ms网络延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            
            // 模拟百度API调用
            // BaiduCoordinateConverter.convert(coord.getLat(), coord.getLng(), ...);
        }
        
        return System.currentTimeMillis() - startTime;
    }
    
    /**
     * 测试高德API调用性能（模拟）
     */
    private static long testAmapApi(List<Coordinate> testData) {
        long startTime = System.currentTimeMillis();
        
        for (Coordinate coord : testData) {
            // 模拟网络延迟
            try {
                Thread.sleep(1); // 模拟1ms网络延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            
            // 模拟高德API调用
            // AMapCoordinateConverter.convert(coord.getLat(), coord.getLng(), ...);
        }
        
        return System.currentTimeMillis() - startTime;
    }
    
    /**
     * 坐标类
     */
    static class Coordinate {
        private double lat;
        private double lng;
        
        public Coordinate(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
        
        public double getLat() { return lat; }
        public double getLng() { return lng; }
    }
}

选型建议

根据不同场景，我们给出以下选型建议：

1. 高性能要求场景

推荐：纯Java代码实现

优势：性能最优，无网络依赖
适用：高频调用、实时性要求高的系统
注意：需要维护算法准确性

2. 快速开发场景

推荐：在线API调用

优势：实现简单，快速上线
适用：原型开发、POC验证
注意：网络依赖，性能受限

3. 地图功能丰富场景

推荐：百度/高德API集成

优势：功能丰富，精度较高
适用：需要多种地图服务的完整解决方案
注意：API调用限制，成本考虑

4. 混合使用策略

public class HybridCoordinateConverter {
    
    // 本地缓存
    private static final Map<String, Coordinate> cache = new ConcurrentHashMap<>();
    
    // 熔断器
    private static final AtomicBoolean apiAvailable = new AtomicBoolean(true);
    
    /**
     * 智能坐标转换
     */
    public static Coordinate smartConvert(double lat, double lng, 
                                        ConversionType fromType, 
                                        ConversionType toType) {
        // 生成缓存key
        String cacheKey = lat + "," + lng + "," + fromType + "," + toType;
        
        // 先查缓存
        Coordinate cached = cache.get(cacheKey);
        if (cached != null) {
            return cached;
        }
        
        // 如果API可用，优先使用API
        if (apiAvailable.get()) {
            try {
                Coordinate result = callExternalApi(lat, lng, fromType, toType);
                // 缓存结果
                cache.put(cacheKey, result);
                return result;
            } catch (Exception e) {
                // API调用失败，标记为不可用
                apiAvailable.set(false);
                // 启动定时任务恢复API状态
                scheduleApiRecovery();
            }
        }
        
        // API不可用时使用本地算法
        Coordinate result = convertLocally(lat, lng, fromType, toType);
        // 缓存结果
        cache.put(cacheKey, result);
        return result;
    }
    
    /**
     * 调用外部API
     */
    private static Coordinate callExternalApi(double lat, double lng, 
                                            ConversionType fromType, 
                                            ConversionType toType) {
        // 这里根据具体需求选择百度或高德API
        // return BaiduCoordinateConverter.convert(lat, lng, ...);
        // 或者
        // return AMapCoordinateConverter.convert(lat, lng, ...);
        return null; // 示例代码
    }
    
    /**
     * 本地转换
     */
    private static Coordinate convertLocally(double lat, double lng, 
                                          ConversionType fromType, 
                                          ConversionType toType) {
        // 使用纯Java实现
        return PureJavaCoordinateConverter.wgs84ToGcj02(lat, lng);
    }
    
    /**
     * 定时恢复API状态
     */
    private static void scheduleApiRecovery() {
        // 使用定时任务在一段时间后重新尝试API
        new Thread(() -> {
            try {
                Thread.sleep(60000); // 1分钟后重试
                apiAvailable.set(true);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
    
    enum ConversionType {
        WGS84, GCJ02, BD09
    }
    
    static class Coordinate {
        private double lat;
        private double lng;
        
        public Coordinate(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
        
        public double getLat() { return lat; }
        public double getLng() { return lng; }
    }
}

最佳实践总结

缓存策略：对频繁转换的坐标进行缓存，减少重复计算
熔断机制：当外部API不可用时自动切换到本地实现
批量处理：尽量使用批量转换API，提高效率
异常处理：完善的异常处理机制，确保系统稳定性
监控告警：对转换成功率、响应时间等关键指标进行监控

标题：Java坐标转换全攻略：3大实现路径让位置服务不再难，后端开发必备技能！
作者：jiangyi
地址：http://jiangyi.space/articles/2025/12/21/1766304283901.html

坐标转换基础概念科普
常见的坐标系类型
为什么需要坐标转换？
坐标转换的基本原理
实现路径一：在线API调用
通用HTTP API调用实现
使用示例
实现路径二：百度地图API集成
百度地图坐标转换API集成
百度地图API使用示例
百度地图API集成注意事项
实现路径三：高德地图API集成
高德地图坐标转换API集成
高德地图API使用示例
高德地图API集成注意事项
实现路径四：纯Java代码实现
WGS84到GCJ02坐标转换算法实现
纯Java实现使用示例
纯Java实现的优势与局限
性能对比与选型建议
性能测试代码
选型建议
1. 高性能要求场景
2. 快速开发场景
3. 地图功能丰富场景
4. 混合使用策略
最佳实践总结

0 评论