<!-- pom.xml (Maven) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.index.GeoSpatialIndexType;
import org.springframework.data.mongodb.core.index.GeoSpatialIndexed;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "locations")
public class LocationEntity {

    @Id
    private String id;
    private String name;

    // 存儲經(jīng)緯度信息，并創(chuàng)建 2dsphere 索引
    @GeoSpatialIndexed(type = GeoSpatialIndexType.GEO_2DSPHERE)
    private GeoJsonPoint location; // [longitude, latitude]

    public LocationEntity() {}

    public LocationEntity(String name, GeoJsonPoint location) {
        this.name = name;
        this.location = location;
    }

    // Getters and Setters
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public GeoJsonPoint getLocation() {
        return location;
    }

    public void setLocation(GeoJsonPoint location) {
        this.location = location;
    }

    @Override
    public String toString() {
        return "LocationEntity{" +
               "id='" + id + '\'' +
               ", name='" + name + '\'' +
               ", location=" + (location != null ? location.getCoordinates() : null) +
               '}';
    }
}

import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Point;
import org.springframework.data.geo.Polygon;
import org.springframework.data.mongodb.repository.MongoRepository;
import java.util.List;

public interface LocationRepository extends MongoRepository<LocationEntity, String> {

    // 1. 查找靠近某個點的文檔 (使用 $nearSphere)
    // Spring Data 會自動使用 $nearSphere 因為索引是 2dsphere
    // Point 來自 org.springframework.data.geo.Point (x=longitude, y=latitude)
    // Distance 來自 org.springframework.data.geo.Distance
    List<LocationEntity> findByLocationNear(Point point, Distance distance);

    // 也可以只按點查找，不限制距離 (結(jié)果按距離排序)
    List<LocationEntity> findByLocationNear(Point point);

    // 2. 查找在指定多邊形內(nèi)的文檔 (使用 $geoWithin)
    // Polygon 來自 org.springframework.data.geo.Polygon
    List<LocationEntity> findByLocationWithin(Polygon polygon);

    // 3. 查找在指定圓形區(qū)域內(nèi)的文檔 (使用 $geoWithin 和 $centerSphere)
    // Circle 來自 org.springframework.data.geo.Circle
    // Spring Data 會將其轉(zhuǎn)換為 $geoWithin 與 $centerSphere
    List<LocationEntity> findByLocationWithin(org.springframework.data.geo.Circle circle);

    // 4. 查找與指定 GeoJSON 幾何圖形相交的文檔 (使用 $geoIntersects)
    // 需要使用 MongoTemplate 或 @Query 來實現(xiàn)更復(fù)雜的 GeoJSON 相交查詢，
    // 因為派生查詢對 $geoIntersects 的支持有限，尤其是對于復(fù)雜的 GeoJSON 輸入。
    // 但簡單的 Point 相交可以。
    // 對于更復(fù)雜的 GeoJSON (如 Polygon)，通常使用 MongoTemplate 或 @Query
    // List<LocationEntity> findByLocationIntersects(GeoJson geometry); // 示例，可能需要自定義實現(xiàn)

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.*;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.geo.GeoJsonPolygon;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;

import jakarta.annotation.PostConstruct;
import java.util.Arrays;
import java.util.List;

@Service
public class LocationService {

    @Autowired
    private LocationRepository locationRepository;

    @Autowired
    private MongoTemplate mongoTemplate;

    @PostConstruct
    public void init() {
        locationRepository.deleteAll(); // 清理舊數(shù)據(jù)

        // 插入一些示例數(shù)據(jù)
        // 故宮 (116.403963, 39.915119)
        locationRepository.save(new LocationEntity("Forbidden City", new GeoJsonPoint(116.403963, 39.915119)));
        // 天安門廣場 (116.3912757, 39.9037078)
        locationRepository.save(new LocationEntity("Tiananmen Square", new GeoJsonPoint(116.3912757, 39.9037078)));
        // 頤和園 (116.275136, 39.999077)
        locationRepository.save(new LocationEntity("Summer Palace", new GeoJsonPoint(116.275136, 39.999077)));
        // 東方明珠 (121.499718, 31.239703)
        locationRepository.save(new LocationEntity("Oriental Pearl Tower", new GeoJsonPoint(121.499718, 31.239703)));
    }

    public void performGeoQueries() {
        System.out.println("--- Performing Geo Queries ---");

        // 中心點: 北京市中心附近 (例如王府井 116.417427, 39.913904)
        Point centerPoint = new Point(116.417427, 39.913904); // longitude, latitude

        // 1. 查找王府井附近 5 公里內(nèi)的地點
        Distance fiveKilometers = new Distance(5, Metrics.KILOMETERS);
        List<LocationEntity> nearWangfujing = locationRepository.findByLocationNear(centerPoint, fiveKilometers);
        System.out.println("\nLocations near Wangfujing (5km):");
        nearWangfujing.forEach(System.out::println); // 應(yīng)該包含故宮和天安門

        // 2. 查找在指定多邊形內(nèi)的地點 (大致覆蓋北京二環(huán)內(nèi))
        // 注意：多邊形的點必須形成閉合環(huán)路，且第一個點和最后一個點相同
        Polygon beijingRing2 = new Polygon(
                new Point(116.30, 39.85), //西南
                new Point(116.50, 39.85), //東南
                new Point(116.50, 39.95), //東北
                new Point(116.30, 39.95), //西北
                new Point(116.30, 39.85)  //閉合
        );
        List<LocationEntity> withinBeijingRing2 = locationRepository.findByLocationWithin(beijingRing2);
        System.out.println("\nLocations within Beijing Ring 2 (approx):");
        withinBeijingRing2.forEach(System.out::println); // 應(yīng)該包含故宮和天安門

        // 3. 查找在指定圓形區(qū)域內(nèi)的地點 (以故宮為圓心，2公里為半徑)
        Point forbiddenCityCoords = new Point(116.403963, 39.915119);
        Distance twoKilometers = new Distance(2, Metrics.KILOMETERS);
        // 對于2dsphere索引, Circle的距離單位會被正確處理 (例如轉(zhuǎn)換為弧度)
        Circle aroundForbiddenCity = new Circle(forbiddenCityCoords, twoKilometers);
        List<LocationEntity> withinCircle = locationRepository.findByLocationWithin(aroundForbiddenCity);
        System.out.println("\nLocations within 2km of Forbidden City:");
        withinCircle.forEach(System.out::println); // 應(yīng)該包含故宮和天安門

        // 4. 使用 MongoTemplate 進行 $geoIntersects 查詢
        // 定義一個 GeoJsonPolygon (注意點順序，逆時針為外部，順時針為內(nèi)部，但通常簡單多邊形即可)
        // 這里用和上面一樣的多邊形，但用 GeoJsonPolygon
        GeoJsonPolygon queryPolygon = new GeoJsonPolygon(
                new Point(116.30, 39.85),
                new Point(116.50, 39.85),
                new Point(116.50, 39.95),
                new Point(116.30, 39.95),
                new Point(116.30, 39.85)
        );
        Query intersectsQuery = new Query(Criteria.where("location").intersects(queryPolygon));
        List<LocationEntity> intersectingLocations = mongoTemplate.find(intersectsQuery, LocationEntity.class);
        System.out.println("\nLocations intersecting with query polygon (MongoTemplate):");
        intersectingLocations.forEach(System.out::println);


        // 5. 使用 MongoTemplate 進行 $nearSphere 查詢，并指定最小和最大距離
        Query nearQueryWithMinMax = new Query(
            Criteria.where("location")
                    .nearSphere(centerPoint) // 使用 Spring Data Point
                    .minDistance(1000 / 6378137.0) // 最小距離1公里 (轉(zhuǎn)換為弧度，MongoDB $nearSphere 需要弧度或米)
                                                   // 或者直接用米: .minDistance(1000) 如果MongoDB版本支持
                    .maxDistance(5000 / 6378137.0) // 最大距離5公里
                                                   // 或者直接用米: .maxDistance(5000)
        );
        // 如果MongoDB 4.0+ 且 Spring Data MongoDB 2.2+, 可以直接用米
        // Query nearQueryWithMinMaxMeters = new Query(
        // Criteria.where("location")
        // .nearSphere(centerPoint)
        // .minDistance(1000.0) // 1000 meters
        // .maxDistance(5000.0) // 5000 meters
        // );
        // List<LocationEntity> nearWithMinMax = mongoTemplate.find(nearQueryWithMinMaxMeters, LocationEntity.class);
        // System.out.println("\nLocations near Wangfujing (1km-5km, MongoTemplate):");
        // nearWithMinMax.forEach(System.out::println);

        // 對于 $nearSphere，Spring Data 的 Repository 方法中的 Distance 對象會自動處理單位轉(zhuǎn)換。
        // 使用 MongoTemplate 時，對于 $minDistance / $maxDistance:
        // - 如果是 `2dsphere` 索引，MongoDB 期望距離單位是米。
        // - 如果是 `2d` 索引，MongoDB 期望距離單位是索引坐標系的單位。
        // Spring Data MongoDB 3.0+ 配合 MongoDB 4.0+，`nearSphere` 可以直接接受米為單位的 `minDistance`/`maxDistance`。
        // 如果使用較舊版本，可能需要將距離轉(zhuǎn)換為弧度（如示例中除以地球半徑）。
        // 簡單的 findByLocationNear(Point, Distance) 通常是更方便的選擇。
    }
}

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class MongoGeoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MongoGeoApplication.class, args);
    }

    @Bean
    CommandLineRunner runner(LocationService locationService) {
        return args -> {
            locationService.performGeoQueries();
        };
    }
}