如何在Java中实现GeoJSON格式？结合Hibernate与MySQL的POJO方案

嘿，我来一步步帮你解决这两个问题，都是Java里处理GeoJSON的常见场景，尤其是结合Hibernate和MySQL的部分，用POJO确实能大大简化流程～

1. 手动拼接（快速简单场景） #

如果只是生成少量结构简单的GeoJSON，直接字符串拼接就能搞定，但缺点是容易出错，只适合临时测试或极简场景：

public String generateSimpleGeoJson() {
    return "{" +
        "\"type\": \"FeatureCollection\"," +
        "\"features\": [" +
            "{" +
                "\"type\": \"Feature\"," +
                "\"geometry\": {" +
                    "\"type\": \"Point\"," +
                    "\"coordinates\": [-77.032, 38.913]" +
                "}," +
                "\"properties\": {" +
                    "\"title\": \"Mapbox\"," +
                    "\"description\": \"Washington, D.C.\"" +
                "}" +
            "}," +
            "{" +
                "\"type\": \"Feature\"," +
                "\"geometry\": {" +
                    "\"type\": \"Point\"," +
                    "\"coordinates\": [-122.414, 37.776]" +
                "}," +
                "\"properties\": {" +
                    "\"title\": \"Mapbox\"," +
                    "\"description\": \"San Francisco, California\"" +
                "}" +
            "}" +
        "]" +
    "}";
}

2. POJO + JSON序列化库（推荐，可维护性高） #

这就是你想要的简化处理方案：先定义对应GeoJSON结构的POJO，再用Jackson（或Gson）自动序列化，完全不用手动拼字符串，后续扩展也方便。

第一步：定义GeoJSON对应POJO

// FeatureCollection.java
import java.util.List;
import com.fasterxml.jackson.annotation.JsonProperty;

public class FeatureCollection {
    @JsonProperty("type")
    private final String type = "FeatureCollection";
    
    @JsonProperty("features")
    private List<Feature> features;

    public FeatureCollection(List<Feature> features) {
        this.features = features;
    }

    // 省略getter/setter
}

// Feature.java
public class Feature {
    @JsonProperty("type")
    private final String type = "Feature";
    
    @JsonProperty("geometry")
    private Geometry geometry;
    
    @JsonProperty("properties")
    private Properties properties;

    public Feature(Geometry geometry, Properties properties) {
        this.geometry = geometry;
        this.properties = properties;
    }

    // 省略getter/setter
}

// Geometry.java
public class Geometry {
    @JsonProperty("type")
    private String type;
    
    @JsonProperty("coordinates")
    private List<Double> coordinates;

    public Geometry(String type, List<Double> coordinates) {
        this.type = type;
        this.coordinates = coordinates;
    }

    // 省略getter/setter
}

// Properties.java
public class Properties {
    @JsonProperty("title")
    private String title;
    
    @JsonProperty("description")
    private String description;

    public Properties(String title, String description) {
        this.title = title;
        this.description = description;
    }

    // 省略getter/setter
}

第二步：用Jackson序列化生成GeoJSON

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;

public class GeoJsonGenerator {
    public static void main(String[] args) throws Exception {
        // 构造第一个Feature
        Geometry dcPoint = new Geometry("Point", Arrays.asList(-77.032, 38.913));
        Properties dcProps = new Properties("Mapbox", "Washington, D.C.");
        Feature dcFeature = new Feature(dcPoint, dcProps);

        // 构造第二个Feature
        Geometry sfPoint = new Geometry("Point", Arrays.asList(-122.414, 37.776));
        Properties sfProps = new Properties("Mapbox", "San Francisco, California");
        Feature sfFeature = new Feature(sfPoint, sfProps);

        // 生成FeatureCollection并序列化
        FeatureCollection collection = new FeatureCollection(Arrays.asList(dcFeature, sfFeature));
        ObjectMapper mapper = new ObjectMapper();
        String geoJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(collection);
        
        System.out.println(geoJson);
    }
}

运行后就能得到格式标准的GeoJSON，后续要加Polygon、LineString等类型，只需扩展Geometry类即可。

MySQL 5.7+支持空间数据类型（如POINT），Hibernate有专门的Spatial扩展来对接，我们可以通过POJO映射实现GeoJSON和数据库空间数据的双向转换。

1. 准备依赖（Maven为例） #

<dependencies>
    <!-- Hibernate Core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.14.Final</version>
    </dependency>
    <!-- Hibernate Spatial 处理空间数据 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-spatial</artifactId>
        <version>5.6.14.Final</version>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
</dependencies>

2. 数据库表设计 #

创建带空间字段的表，指定坐标系为WGS84（SRID 4326，对应GeoJSON的经纬度）：

CREATE TABLE location_feature (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    description TEXT,
    location POINT NOT NULL SRID 4326
);

3. 定义Hibernate实体POJO #

用Hibernate Spatial提供的org.locationtech.jts.geom.Point映射MySQL的POINT字段：

import javax.persistence.*;
import org.locationtech.jts.geom.Point;

@Entity
@Table(name = "location_feature")
public class LocationFeatureEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String title;
    
    private String description;
    
    // 映射MySQL的POINT字段，指定坐标系
    @Column(columnDefinition = "POINT SRID 4326")
    private Point location;

    // 空构造函数（Hibernate要求）
    public LocationFeatureEntity() {}

    public LocationFeatureEntity(String title, String description, Point location) {
        this.title = title;
        this.description = description;
        this.location = location;
    }

    // 省略getter/setter
}

4. GeoJSON与实体类互转 #

从GeoJSON转实体（存入数据库）

用JTS的GeometryFactory把GeoJSON的坐标转换成Point对象：

import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Coordinate;
import java.util.List;

public class GeoJsonToEntityConverter {
    private static final GeometryFactory GEOMETRY_FACTORY = new GeometryFactory();

    public static LocationFeatureEntity convert(Feature feature) {
        Geometry geoJsonGeometry = feature.getGeometry();
        List<Double> coords = geoJsonGeometry.getCoordinates();
        // GeoJSON坐标顺序是[经度, 纬度]，和JTS的Coordinate一致
        Coordinate coordinate = new Coordinate(coords.get(0), coords.get(1));
        Point point = GEOMETRY_FACTORY.createPoint(coordinate);
        point.setSRID(4326);

        Properties props = feature.getProperties();
        return new LocationFeatureEntity(props.getTitle(), props.getDescription(), point);
    }
}

从实体转GeoJSON（从数据库查询后生成）

import java.util.Arrays;

public class EntityToGeoJsonConverter {
    public static Feature convert(LocationFeatureEntity entity) {
        Point dbPoint = entity.getLocation();
        Coordinate coord = dbPoint.getCoordinate();
        List<Double> coords = Arrays.asList(coord.getX(), coord.getY());
        Geometry geometry = new Geometry("Point", coords);

        Properties props = new Properties(entity.getTitle(), entity.getDescription());
        return new Feature(geometry, props);
    }
}

5. 业务层示例（保存+查询） #

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
import java.util.stream.Collectors;

public class GeoJsonHibernateDemo {
    public static void main(String[] args) {
        // 初始化SessionFactory
        SessionFactory sessionFactory = new Configuration()
                .configure("hibernate.cfg.xml") // 配置数据库连接
                .addAnnotatedClass(LocationFeatureEntity.class)
                .buildSessionFactory();

        // 保存数据
        try (Session session = sessionFactory.openSession()) {
            session.beginTransaction();
            // 构造GeoJSON Feature并转成实体
            Geometry dcPoint = new Geometry("Point", Arrays.asList(-77.032, 38.913));
            Properties dcProps = new Properties("Mapbox", "Washington, D.C.");
            Feature dcFeature = new Feature(dcPoint, dcProps);
            LocationFeatureEntity entity = GeoJsonToEntityConverter.convert(dcFeature);
            
            session.save(entity);
            session.getTransaction().commit();
        }

        // 查询数据并生成GeoJSON
        try (Session session = sessionFactory.openSession()) {
            List<LocationFeatureEntity> entities = session.createQuery(
                    "from LocationFeatureEntity", LocationFeatureEntity.class
            ).list();
            
            List<Feature> features = entities.stream()
                    .map(EntityToGeoJsonConverter::convert)
                    .collect(Collectors.toList());
            FeatureCollection collection = new FeatureCollection(features);
            
            ObjectMapper mapper = new ObjectMapper();
            String geoJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(collection);
            System.out.println(geoJson);
        } catch (Exception e) {
            e.printStackTrace();
        }

        sessionFactory.close();
    }
}

注意事项 #

• 坐标顺序：GeoJSON和JTS的Coordinate都是[经度, 纬度]，不要搞反。
• 统一SRID：全程用WGS84（SRID 4326），避免坐标系混乱。
• 确保MySQL空间扩展已开启（默认是开启的）。

内容的提问来源于stack exchange，提问作者Sebastian Cordova