Java后端开发者的空间计算利器：JTS核心实战与深度解析

最近在做一个物流配送路径优化的项目，客户要求系统能实时判断仓库、配送点和禁行区域的空间关系。一开始我尝试用简单的数学公式计算点和多边形的关系，结果发现边界情况处理起来异常棘手，一个坐标精度问题就能让整个判断逻辑崩掉。后来团队里的GIS专家推荐了JTS，用上之后才发现，原来空间计算可以这么优雅。

JTS（Java Topology Suite）对于需要处理地理空间数据的Java开发者来说，就像瑞士军刀一样实用。它不仅仅是前端Turf.js的Java版本，更是一套完整的、符合OGC标准的空间计算引擎。无论是电商平台的配送范围判断，还是共享出行服务的电子围栏，甚至是智慧城市中的设施管理，JTS都能提供稳定可靠的空间关系计算能力。

这篇文章我会结合自己实际项目中的经验，从基础概念到核心场景，带你深入掌握JTS的使用技巧。我不会只给你一堆API文档的翻译，而是聚焦于那些真正在业务中高频出现的场景，每个场景都会给出可以直接复用的代码示例，同时分享一些我踩过的坑和优化经验。

1. JTS生态与核心概念：不只是“Java版的Turf”

很多人第一次接触JTS时，会把它简单地理解为“后端版的Turf.js”。这种类比有一定道理，但低估了JTS的深度和广度。JTS诞生于1990年代，比Turf.js早了近二十年，它是OGC简单要素规范在Java领域的权威实现，而Turf.js则是后来为了前端GIS分析需求而出现的JavaScript库。

1.1 JTS在Java空间计算生态中的位置

先看一个简单的依赖引入，这是使用JTS的第一步：

<dependency>
    <groupId>org.locationtech.jts</groupId>
    <artifactId>jts-core</artifactId>
    <version>1.18.2</version>
</dependency>

目前最新稳定版是1.18.2，我建议直接使用这个版本，它在性能和稳定性方面都有不错的表现。如果你需要处理GeoJSON格式的数据，还需要额外引入：

<dependency>
    <groupId>org.locationtech.jts.io</groupId>
    <artifactId>jts-io-common</artifactId>
<version>1.18.2</version>
</dependency>

注意：JTS的groupId在2016年从com.vividsolutions.jts迁移到了org.locationtech.jts，如果你在老旧项目中看到前者，需要升级到新版本。

JTS的核心价值在于它实现了精确的空间谓词计算。什么叫空间谓词？简单说就是判断两个几何对象之间关系的布尔函数，比如“A是否包含B”、“A和B是否相交”。这些看似简单的判断，在浮点数精度、边界情况、奇异几何形状面前，很容易出错。

1.2 理解JTS的核心数据模型

JTS的数据模型围绕几个核心类构建，理解这些类的关系至关重要：

类名	说明	对应OGC类型	常用场景
Coordinate	轻量级坐标点，只有x,y(可选z)坐标	坐标点	构建几何对象的基本单元
Geometry	所有几何类型的抽象父类	Geometry	类型判断、通用操作
Point	点几何	Point	位置标记、距离计算
LineString	线串（折线）	LineString	路径、边界线
LinearRing	闭合线串（首尾相同）	LinearRing	多边形边界
Polygon	多边形	Polygon	区域范围、地理围栏
GeometryCollection	几何集合	GeometryCollection	复杂空间对象

这里有个容易混淆的点：Coordinate和Point的区别。Coordinate是纯粹的坐标数据容器，没有空间参考信息，而Point是一个完整的几何对象，包含精度模型、空间参考等元数据。在实际使用中，创建几何对象时通常先创建Coordinate，然后通过GeometryFactory生成对应的几何对象。

// 创建Coordinate - 轻量级坐标
Coordinate coord = new Coordinate(116.404, 39.915);

// 创建Point - 完整的几何对象
GeometryFactory factory = new GeometryFactory();
Point point = factory.createPoint(coord);

System.out.println("Coordinate: " + coord);
System.out.println("Point as WKT: " + point.toText());

输出结果会是：

Coordinate: (116.404, 39.915)
Point as WKT: POINT (116.404 39.915)

1.3 WKT：几何对象的通用语言

WKT（Well-Known Text）是GIS领域的“通用语言”，它用文本形式描述几何对象。JTS提供了完整的WKT读写支持，这在系统间数据交换、调试、数据持久化时非常有用。

WKT的基本格式规则：

• 点：POINT (x y)
• 线串：LINESTRING (x1 y1, x2 y2, ...)
• 多边形：POLYGON ((x1 y1, x2 y2, ..., x1 y1))（注意双括号和首尾闭合）
• 多多边形：MULTIPOLYGON (((...)), ((...)))

在实际项目中，我经常用WKT来快速测试几何关系。JTS还提供了JTSTestBuilder这个可视化工具，可以直接绘制几何图形并查看WKT表示，对于调试复杂空间关系非常有帮助。

2. 空间关系判断：从理论到实战

空间关系判断是JTS最核心的功能，也是业务中最常用的部分。OGC定义了8种基本空间关系，JTS不仅完整实现了这些关系，还提供了更丰富的操作方法。

2.1 九交模型：空间关系的数学基础

要真正理解JTS的空间关系判断，需要了解DE-9IM（Dimensionally Extended Nine-Intersection Model）模型。这个模型通过比较两个几何对象内部（Interior）、边界（Boundary）和外部（Exterior）的交集维度来判断关系。

对于大多数开发者来说，不需要深入理解九交矩阵的计算细节，但了解基本概念有助于理解为什么某些看似“应该成立”的关系判断会返回意外结果。

JTS中的主要空间谓词方法：

// 创建两个测试几何对象
GeometryFactory gf = new GeometryFactory();
Polygon polygon = gf.createPolygon(new Coordinate[]{
    new Coordinate(0, 0),
    new Coordinate(0, 10),
    new Coordinate(10, 10),
    new Coordinate(10, 0),
    new Coordinate(0, 0)
});

Point insidePoint = gf.createPoint(new Coordinate(5, 5));
Point boundaryPoint = gf.createPoint(new Coordinate(0, 5));
Point outsidePoint = gf.createPoint(new Coordinate(15, 15));

// 基本关系判断
System.out.println("点在面内: " + polygon.contains(insidePoint));      // true
System.out.println("点在边界: " + polygon.touches(boundaryPoint));     // true
System.out.println("点在面外: " + polygon.disjoint(outsidePoint));     // true

// 创建另一个多边形（部分重叠）
Polygon overlappingPolygon = gf.createPolygon(new Coordinate[]{
    new Coordinate(5, 5),
    new Coordinate(5, 15),
    new Coordinate(15, 15),
    new Coordinate(15, 5),
    new Coordinate(5, 5)
});

System.out.println("多边形相交: " + polygon.intersects(overlappingPolygon));  // true
System.out.println("多边形重叠: " + polygon.overlaps(overlappingPolygon));    // true

2.2 点面包含判断的实战细节

点面包含判断看起来简单，但在实际业务中会遇到各种边界情况。比如：点在多边形的顶点上、点在多边形的边上、多边形有孔洞（岛）等情况。

场景一：判断配送地址是否在服务范围内

假设我们有一个外卖平台，需要判断用户地址是否在商家的配送范围内。商家的配送范围可能是不规则多边形。

public class DeliveryService {
    private GeometryFactory factory = new GeometryFactory();
    
    /**
     * 判断地址是否在配送范围内
     * @param deliveryAreaWKT 配送范围的WKT表示
     * @param addressLng 地址经度
     * @param addressLat 地址纬度
     * @return 是否在范围内
     */
    public boolean isAddressInDeliveryArea(String deliveryAreaWKT, 
                                          double addressLng, double addressLat) {
        try {
            WKTReader reader = new WKTReader(factory);
            Polygon deliveryArea = (Polygon) reader.read(deliveryAreaWKT);
            
            Point addressPoint = factory.createPoint(
                new Coordinate(addressLng, addressLat));
            
            // 使用contains方法判断
            return deliveryArea.contains(addressPoint);
            
        } catch (ParseException e) {
            // 实际项目中应该记录日志并抛出业务异常
            throw new IllegalArgumentException("无效的配送范围WKT格式", e);
        }
    }
    
    /**
     * 处理带孔洞的配送范围（如避开湖泊、禁行区）
     */
    public boolean isAddressInAreaWithHoles(String polygonWKT, String holesWKT, 
                                           double lng, double lat) {
        try {
            WKTReader reader = new WKTReader(factory);
            
            // 读取外壳
            Polygon shell = (Polygon) reader.read(polygonWKT);
            
            // 读取孔洞（多个）
            Polygon hole = (Polygon) reader.read(holesWKT);
            
            // 创建带孔洞的多边形
            Polygon polygonWithHole = factory.createPolygon(
                shell.getExteriorRing().getCoordinates(),
                new LinearRing[]{hole.getExteriorRing()}
            );
            
            Point point = factory.createPoint(new Coordinate(lng, lat));
            
            // 对于带孔洞的多边形，点在孔洞内不算在范围内
            return polygonWithHole.contains(point);
            
        } catch (ParseException e) {
            throw new IllegalArgumentException("WKT格式错误", e);
        }
    }
}

提示：在实际业务中，如果配送范围是固定的，应该将Polygon对象缓存起来，避免每次判断都重新解析WKT，这能显著提升性能。

边界情况处理经验：

1. 精度问题：地理坐标通常是经纬度，直接使用contains可能会因为浮点数精度导致边界点判断不一致。JTS提供了PrecisionModel来处理精度问题。

// 使用指定精度的GeometryFactory
double scale = 100000; // 保留5位小数精度
PrecisionModel pm = new PrecisionModel(scale);
GeometryFactory preciseFactory = new GeometryFactory(pm);

// 使用这个factory创建的几何对象会应用精度模型

2. 点在边界上的处理：业务上有时需要明确区分“在内部”和“在边界上”。JTS的touches()方法可以判断点是否在边界上，但注意：如果点在顶点上，touches()返回true，contains()返回false。

3. 大范围多边形：当多边形覆盖范围很大（比如整个城市），且需要频繁判断时，可以考虑使用空间索引优化。JTS提供了STRtree等空间索引结构。

2.3 线面相交与空间连接

在路径规划、管网分析等场景中，经常需要判断线与面的相交关系。JTS提供了多种相交相关的操作方法。

场景二：判断配送路线是否经过禁行区域

public class RoutePlanningService {
    
    public boolean isRouteThroughRestrictedArea(String routeWKT, 
                                               String restrictedAreaWKT) {
        try {
            WKTReader reader = new WKTReader();
            Geometry route = reader.read(routeWKT);
            Geometry restrictedArea = reader.read(restrictedAreaWKT);
            
            // 判断是否相交
            if (route.intersects(restrictedArea)) {
                // 获取相交部分
                Geometry intersection = route.intersection(restrictedArea);
                
                // 如果相交部分有长度（不是点接触），则认为经过禁行区
                return intersection.getLength() > 0.0001; // 设置一个阈值
            }
            return false;
            
        } catch (ParseException e) {
            throw new IllegalArgumentException("WKT格式错误", e);
        }
    }
    
    /**
     * 获取路线在禁行区内的部分（用于计算违规距离）
     */
    public Geometry getRouteInRestrictedArea(String routeWKT, 
                                            String restrictedAreaWKT) {
        try {
            WKTReader reader = new WKTReader();
            Geometry route = reader.read(routeWKT);
            Geometry restrictedArea = reader.read(restrictedAreaWKT);
            
            // 计算交集
            return route.intersection(restrictedArea);
            
        } catch (ParseException e) {
            throw new IllegalArgumentException("WKT格式错误", e);
        }
    }
}

性能优化技巧：

对于需要频繁进行相交判断的场景（比如实时轨迹监控），每次都进行完整的几何计算开销很大。可以采用两级判断策略：

1. 先用外包矩形（Envelope）进行快速过滤
2. 只有外包矩形相交时，才进行精确的几何计算

public boolean fastIntersects(Geometry geom1, Geometry geom2) {
    // 第一级：外包矩形判断（快速过滤）
    if (!geom1.getEnvelopeInternal().intersects(geom2.getEnvelopeInternal())) {
        return false;
    }
    
    // 第二级：精确几何计算
    return geom1.intersects(geom2);
}

3. 几何度量计算：距离、面积与中心点

几何度量是空间分析的基础，JTS提供了准确的距离、面积、长度等计算功能。但需要注意的是，JTS默认使用笛卡尔坐标系进行计算，对于地理坐标（经纬度）需要特殊处理。

3.1 距离计算的不同场景

场景三：计算两个地理位置之间的距离

这是LBS应用中最常见的需求。JTS的distance()方法计算的是平面距离，对于经纬度坐标，需要先进行投影转换，或者使用专门的大圆距离公式。

public class DistanceCalculator {
    
    private static final double EARTH_RADIUS = 6371000; // 地球半径，单位米
    
    /**
     * 使用JTS计算平面距离（适用于小范围、已投影的坐标）
     */
    public double calculatePlanarDistance(double x1, double y1, 
                                         double x2, double y2) {
        GeometryFactory factory = new GeometryFactory();
        Point point1 = factory.createPoint(new Coordinate(x1, y1));
        Point point2 = factory.createPoint(new Coordinate(x2, y2));
        
        return point1.distance(point2);
    }
    
    /**
     * 计算大圆距离（适用于经纬度坐标）
     * 使用Haversine公式
     */
    public double calculateGreatCircleDistance(double lon1, double lat1,
                                              double lon2, double lat2) {
        double dLat = Math.toRadians(lat2 - lat1);
        double dLon = Math.toRadians(lon2 - lon1);
        
        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                   Math.cos(Math.toRadians(lat1)) * 
                   Math.cos(Math.toRadians(lat2)) *
                   Math.sin(dLon / 2) * Math.sin(dLon / 2);
        
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        
        return EARTH_RADIUS * c;
    }
    
    /**
     * 计算点到线的最短距离
     */
    public double distancePointToLine(Point point, LineString line) {
        // 使用DistanceOp进行精确计算
        DistanceOp distanceOp = new DistanceOp(point, line);
        return distanceOp.distance();
    }
    
    /**
     * 计算点到面的最短距离（如果点在面内，距离为0）
     */
    public double distancePointToPolygon(Point point, Polygon polygon) {
        if (polygon.contains(point)) {
            return 0.0;
        }
        
        // 计算到边界的最短距离
        DistanceOp distanceOp = new DistanceOp(point, polygon.getBoundary());
        return distanceOp.distance();
    }
}

注意：对于地理距离计算，我建议使用专门的地理计算库（如GeoTools）或自己实现大圆距离公式。JTS的平面距离计算只适用于投影坐标系或小范围区域。

3.2 面积与长度计算

面积和长度计算在GIS分析中非常重要，比如计算地块面积、道路长度等。

public class MeasurementService {
    
    /**
     * 计算多边形面积（平面坐标系）
     */
    public double calculateArea(Polygon polygon) {
        return polygon.getArea();
    }
    
    /**
     * 计算线串长度
     */
    public double calculateLength(LineString line) {
        return line.getLength();
    }
    
    /**
     * 计算地理多边形的近似面积（经纬度坐标）
     * 使用球面面积公式
     */
    public double calculateSphericalArea(Polygon polygon) {
        Coordinate[] coords = polygon.getExteriorRing().getCoordinates();
        double area = 0.0;
        
        if (coords.length > 2) {
            for (int i = 0; i < coords.length - 1; i++) {
                double lon1 = Math.toRadians(coords[i].x);
                double lat1 = Math.toRadians(coords[i].y);
                double lon2 = Math.toRadians(coords[i + 1].x);
                double lat2 = Math.toRadians(coords[i + 1].y);
                
                area += (lon2 - lon1) * 
                       (2 + Math.sin(lat1) + Math.sin(lat2));
            }
            
            area = area * 6371000 * 6371000 / 2.0;
        }
        
        return Math.abs(area);
    }
    
    /**
     * 计算多边形的中心点（质心）
     */
    public Point calculateCentroid(Polygon polygon) {
        return polygon.getCentroid();
    }
    
    /**
     * 计算多边形的最小外接矩形
     */
    public Envelope calculateBoundingBox(Polygon polygon) {
        return polygon.getEnvelopeInternal();
    }
}

3.3 中心点计算的业务应用

中心点计算在多个业务场景中都有应用，比如：

• 为配送区域生成一个代表性的中心点用于地图显示
• 计算多个设施的平均位置
• 为聚类分析提供初始中心

public class CenterPointService {
    
    /**
     * 计算多个点的中心点（平均中心）
     */
    public Point calculatePointsCenter(List<Point> points) {
        if (points == null || points.isEmpty()) {
            return null;
        }
        
        double sumX = 0.0;
        double sumY = 0.0;
        
        for (Point point : points) {
            sumX += point.getX();
            sumY += point.getY();
        }
        
        GeometryFactory factory = points.get(0).getFactory();
        return factory.createPoint(
            new Coordinate(sumX / points.size(), sumY / points.size()));
    }
    
    /**
     * 计算加权中心点（考虑每个点的重要性）
     */
    public Point calculateWeightedCenter(Map<Point, Double> weightedPoints) {
        if (weightedPoints == null || weightedPoints.isEmpty()) {
            return null;
        }
        
        double sumX = 0.0;
        double sumY = 0.0;
        double totalWeight = 0.0;
        
        for (Map.Entry<Point, Double> entry : weightedPoints.entrySet()) {
            Point point = entry.getKey();
            double weight = entry.getValue();
            
            sumX += point.getX() * weight;
            sumY += point.getY() * weight;
            totalWeight += weight;
        }
        
        GeometryFactory factory = weightedPoints.keySet().iterator().next().getFactory();
        return factory.createPoint(
            new Coordinate(sumX / totalWeight, sumY / totalWeight));
    }
}

4. 几何操作与空间分析

除了基本的关系判断和度量计算，JTS还提供了丰富的几何操作功能，这些功能在空间分析中非常有用。

4.1 缓冲区分析

缓冲区分析是GIS中的核心功能之一，用于生成指定距离内的区域。在业务中常用于：

• 生成服务覆盖范围
• 安全警戒区域
• 影响范围分析

public class BufferAnalysisService {
    
    private GeometryFactory factory = new GeometryFactory();
    
    /**
     * 创建点缓冲区（圆形区域）
     */
    public Geometry createPointBuffer(Point point, double distance) {
        return point.buffer(distance);
    }
    
    /**
     * 创建线缓冲区（带状区域）
     */
    public Geometry createLineBuffer(LineString line, double distance) {
        return line.buffer(distance);
    }
    
    /**
     * 创建多边形缓冲区（外扩区域）
     */
    public Geometry createPolygonBuffer(Polygon polygon, double distance) {
        return polygon.buffer(distance);
    }
    
    /**
     * 创建不同端点的线缓冲区
     * @param endCapStyle 端点样式：BufferOp.CAP_ROUND, CAP_FLAT, CAP_SQUARE
     */
    public Geometry createLineBufferWithCap(LineString line, 
                                          double distance, int endCapStyle) {
        BufferParameters params = new BufferParameters();
        params.setEndCapStyle(endCapStyle);
        
        return BufferOp.bufferOp(line, distance, params);
    }
    
    /**
     * 创建单侧缓冲区（只在左侧或右侧）
     */
    public Geometry createSingleSideBuffer(LineString line, 
                                         double distance, boolean leftSide) {
        BufferParameters params = new BufferParameters();
        params.setSingleSided(true);
        
        // 对于单侧缓冲区，距离的正负表示方向
        double bufferDistance = leftSide ? distance : -distance;
        
        return BufferOp.bufferOp(line, bufferDistance, params);
    }
}

缓冲区分析的实际应用案例：

在智慧园区项目中，我们需要为消防通道生成缓冲区，确保通道两侧一定范围内没有障碍物。使用单侧缓冲区可以分别检查左右两侧的情况。

// 消防通道线
LineString fireLane = ...;

// 生成左侧3米缓冲区
Geometry leftBuffer = createSingleSideBuffer(fireLane, 3.0, true);

// 生成右侧3米缓冲区  
Geometry rightBuffer = createSingleSideBuffer(fireLane, 3.0, false);

// 检查缓冲区范围内是否有障碍物
List<Geometry> obstacles = ...;
for (Geometry obstacle : obstacles) {
    if (leftBuffer.intersects(obstacle)) {
        System.out.println("左侧缓冲区发现障碍物");
    }
    if (rightBuffer.intersects(obstacle)) {
        System.out.println("右侧缓冲区发现障碍物");
    }
}

4.2 几何运算：并集、交集、差集

几何运算用于组合或分析多个几何对象，在空间分析中非常有用。

public class GeometryOperationService {
    
    /**
     * 计算两个几何对象的并集
     */
    public Geometry union(Geometry geom1, Geometry geom2) {
        return geom1.union(geom2);
    }
    
    /**
     * 计算两个几何对象的交集
     */
    public Geometry intersection(Geometry geom1, Geometry geom2) {
        return geom1.intersection(geom2);
    }
    
    /**
     * 计算几何差集（geom1 - geom2）
     */
    public Geometry difference(Geometry geom1, Geometry geom2) {
        return geom1.difference(geom2);
    }
    
    /**
     * 计算对称差集（只在其中一个几何对象中的部分）
     */
    public Geometry symDifference(Geometry geom1, Geometry geom2) {
        return geom1.symDifference(geom2);
    }
    
    /**
     * 合并多个几何对象
     */
    public Geometry unionAll(List<Geometry> geometries) {
        if (geometries == null || geometries.isEmpty()) {
            return null;
        }
        
        Geometry result = geometries.get(0);
        for (int i = 1; i < geometries.size(); i++) {
            result = result.union(geometries.get(i));
        }
        
        return result;
    }
    
    /**
     * 计算多个几何对象的公共部分
     */
    public Geometry intersectionAll(List<Geometry> geometries) {
        if (geometries == null || geometries.isEmpty()) {
            return null;
        }
        
        Geometry result = geometries.get(0);
        for (int i = 1; i < geometries.size(); i++) {
            result = result.intersection(geometries.get(i));
            // 如果中间结果为空，可以提前结束
            if (result.isEmpty()) {
                break;
            }
        }
        
        return result;
    }
}

业务应用示例：配送区域合并

假设一个外卖平台有多个商家，每个商家有自己的配送范围。平台想要展示所有商家的总配送范围，就需要合并这些多边形。

public class DeliveryAreaService {
    
    public Geometry getCombinedDeliveryArea(List<String> merchantIds) {
        List<Geometry> deliveryAreas = new ArrayList<>();
        
        // 从数据库获取每个商家的配送范围
        for (String merchantId : merchantIds) {
            String deliveryAreaWKT = getDeliveryAreaFromDB(merchantId);
            if (deliveryAreaWKT != null) {
                try {
                    WKTReader reader = new WKTReader();
                    Geometry area = reader.read(deliveryAreaWKT);
                    deliveryAreas.add(area);
                } catch (ParseException e) {
                    // 记录日志，跳过错误数据
                    log.warn("商家{}的配送范围格式错误", merchantId, e);
                }
            }
        }
        
        // 合并所有配送范围
        GeometryOperationService service = new GeometryOperationService();
        return service.unionAll(deliveryAreas);
    }
    
    /**
     * 计算多个配送范围的公共区域（可配送所有商家的区域）
     */
    public Geometry getCommonDeliveryArea(List<String> merchantIds) {
        List<Geometry> deliveryAreas = new ArrayList<>();
        
        for (String merchantId : merchantIds) {
            String deliveryAreaWKT = getDeliveryAreaFromDB(merchantId);
            if (deliveryAreaWKT != null) {
                try {
                    WKTReader reader = new WKTReader();
                    Geometry area = reader.read(deliveryAreaWKT);
                    deliveryAreas.add(area);
                } catch (ParseException e) {
                    log.warn("商家{}的配送范围格式错误", merchantId, e);
                }
            }
        }
        
        GeometryOperationService service = new GeometryOperationService();
        return service.intersectionAll(deliveryAreas);
    }
    
    private String getDeliveryAreaFromDB(String merchantId) {
        // 实际项目中从数据库查询
        return null;
    }
}

4.3 凸包与凹包计算

凸包是包含所有点的最小凸多边形，在空间分析中有多种应用。

public class HullService {
    
    /**
     * 计算点的凸包
     */
    public Geometry computeConvexHull(List<Point> points) {
        GeometryFactory factory = new GeometryFactory();
        GeometryCollection gc = factory.createGeometryCollection(
            points.toArray(new Geometry[0]));
        
        return gc.convexHull();
    }
    
    /**
     * 计算凹包（Alpha Shape）
     * JTS本身不直接支持凹包，但可以通过Delaunay三角剖分实现
     */
    public Geometry computeConcaveHull(List<Point> points, double alpha) {
        // 使用DelaunayTriangulationBuilder构建三角网
        DelaunayTriangulationBuilder builder = new DelaunayTriangulationBuilder();
        builder.setSites(points);
        
        Geometry triangles = builder.getTriangles(factory);
        
        // 根据alpha值过滤三角形
        List<Polygon> filteredTriangles = new ArrayList<>();
        
        if (triangles instanceof GeometryCollection) {
            GeometryCollection triangleCollection = (GeometryCollection) triangles;
            for (int i = 0; i < triangleCollection.getNumGeometries(); i++) {
                Geometry triangle = triangleCollection.getGeometryN(i);
                if (triangle instanceof Polygon) {
                    // 计算三角形的外接圆半径
                    double circumradius = calculateCircumradius((Polygon) triangle);
                    
                    // 如果外接圆半径小于alpha，保留该三角形
                    if (circumradius < alpha) {
                        filteredTriangles.add((Polygon) triangle);
                    }
                }
            }
        }
        
        // 合并所有三角形
        GeometryOperationService opService = new GeometryOperationService();
        return opService.unionAll(new ArrayList<>(filteredTriangles));
    }
    
    private double calculateCircumradius(Polygon triangle) {
        // 计算三角形外接圆半径的简化实现
        Coordinate[] coords = triangle.getCoordinates();
        if (coords.length < 4) { // 三角形有4个点（首尾相同）
            return 0;
        }
        
        double a = coords[0].distance(coords[1]);
        double b = coords[1].distance(coords[2]);
        double c = coords[2].distance(coords[0]);
        
        double s = (a + b + c) / 2;
        double area = Math.sqrt(s * (s - a) * (s - b) * (s - c));
        
        if (area == 0) {
            return 0;
        }
        
        return (a * b * c) / (4 * area);
    }
}

5. 性能优化与最佳实践

在实际生产环境中使用JTS时，性能是需要重点考虑的因素。几何计算通常是CPU密集型操作，特别是在处理大量数据或复杂几何时。

5.1 空间索引的应用

JTS提供了几种空间索引结构，最常用的是STRtree。空间索引可以显著提升空间查询的性能。

public class SpatialIndexService {
    
    private STRtree spatialIndex = new STRtree();
    
    /**
     * 构建空间索引
     */
    public void buildIndex(List<Geometry> geometries) {
        for (Geometry geom : geometries) {
            spatialIndex.insert(geom.getEnvelopeInternal(), geom);
        }
        spatialIndex.build();
    }
    
    /**
     * 查询与指定范围相交的几何对象
     */
    public List<Geometry> query(Envelope searchEnv) {
        return spatialIndex.query(searchEnv);
    }
    
    /**
     * 查询与指定几何对象相交的几何对象
     */
    public List<Geometry> query(Geometry searchGeom) {
        return spatialIndex.query(searchGeom.getEnvelopeInternal());
    }
    
    /**
     * 批量查询优化
     */
    public Map<Geometry, List<Geometry>> batchQuery(List<Geometry> searchGeoms) {
        Map<Geometry, List<Geometry>> results = new HashMap<>();
        
        // 先收集所有查询范围
        List<Envelope> envelopes = new ArrayList<>();
        for (Geometry geom : searchGeoms) {
            envelopes.add(geom.getEnvelopeInternal());
        }
        
        // 批量查询（STRtree支持批量查询优化）
        List[] queryResults = spatialIndex.query(envelopes.toArray(new Envelope[0]));
        
        for (int i = 0; i < searchGeoms.size(); i++) {
            results.put(searchGeoms.get(i), queryResults[i]);
        }
        
        return results;
    }
}

使用场景示例：实时轨迹监控

在车辆监控系统中，需要实时判断车辆是否进入特定区域（如电子围栏）。如果有成千上万个电子围栏，每次遍历检查是不可行的。

public class GeoFenceMonitor {
    
    private STRtree fenceIndex = new STRtree();
    private Map<String, Geometry> fenceMap = new HashMap<>();
    
    /**
     * 初始化电子围栏索引
     */
    public void initFences(List<GeoFence> fences) {
        for (GeoFence fence : fences) {
            try {
                WKTReader reader = new WKTReader();
                Geometry geom = reader.read(fence.getBoundaryWKT());
                
                fenceIndex.insert(geom.getEnvelopeInternal(), fence.getId());
                fenceMap.put(fence.getId(), geom);
                
            } catch (ParseException e) {
                log.error("电子围栏{}的边界格式错误", fence.getId(), e);
            }
        }
        fenceIndex.build();
    }
    
    /**
     * 检查车辆位置
     */
    public List<String> checkVehiclePosition(double lng, double lat) {
        GeometryFactory factory = new GeometryFactory();
        Point vehiclePoint = factory.createPoint(new Coordinate(lng, lat));
        
        // 第一步：使用空间索引快速过滤
        List<String> candidateFenceIds = fenceIndex.query(
            vehiclePoint.getEnvelopeInternal());
        
        // 第二步：精确判断
        List<String> enteredFences = new ArrayList<>();
        for (String fenceId : candidateFenceIds) {
            Geometry fence = fenceMap.get(fenceId);
            if (fence.contains(vehiclePoint)) {
                enteredFences.add(fenceId);
            }
        }
        
        return enteredFences;
    }
}

5.2 几何简化与精度控制

在处理大规模地理数据时，几何简化可以显著提升性能。JTS提供了多种简化算法。

public class GeometrySimplificationService {
    
    /**
     * 使用Douglas-Peucker算法简化几何
     */
    public Geometry simplify(Geometry geometry, double distanceTolerance) {
        return TopologyPreservingSimplifier.simplify(geometry, distanceTolerance);
    }
    
    /**
     * 保持拓扑结构的简化
     */
    public Geometry simplifyPreserveTopology(Geometry geometry, 
                                           double distanceTolerance) {
        DouglasPeuckerSimplifier simplifier = new DouglasPeuckerSimplifier(geometry);
        simplifier.setDistanceTolerance(distanceTolerance);
        return simplifier.getResultGeometry();
    }
    
    /**
     * 简化线串（减少点数）
     */
    public LineString simplifyLineString(LineString line, double tolerance) {
        Coordinate[] coords = line.getCoordinates();
        List<Coordinate> simplified = new ArrayList<>();
        
        // 简单的垂距简化算法实现
        simplified.add(coords[0]);
        simplifyRecursive(coords, 0, coords.length - 1, tolerance, simplified);
        simplified.add(coords[coords.length - 1]);
        
        GeometryFactory factory = line.getFactory();
        return factory.createLineString(
            simplified.toArray(new Coordinate[0]));
    }
    
    private void simplifyRecursive(Coordinate[] coords, int start, int end,
                                 double tolerance, List<Coordinate> result) {
        if (end - start < 1) {
            return;
        }
        
        double maxDistance = 0;
        int maxIndex = start;
        
        // 找到距离起点和终点连线最远的点
        for (int i = start + 1; i < end; i++) {
            double distance = perpendicularDistance(
                coords[i], coords[start], coords[end]);
            
            if (distance > maxDistance) {
                maxDistance = distance;
                maxIndex = i;
            }
        }
        
        // 如果最大距离大于容差，递归处理
        if (maxDistance > tolerance) {
            simplifyRecursive(coords, start, maxIndex, tolerance, result);
            result.add(coords[maxIndex]);
            simplifyRecursive(coords, maxIndex, end, tolerance, result);
        }
    }
    
    private double perpendicularDistance(Coordinate point, 
                                       Coordinate lineStart, Coordinate lineEnd) {
        double area = Math.abs(0.5 * (lineStart.x * (lineEnd.y - point.y) +
                                     lineEnd.x * (point.y - lineStart.y) +
                                     point.x * (lineStart.y - lineEnd.y)));
        
        double lineLength = lineStart.distance(lineEnd);
        
        return lineLength == 0 ? 0 : (2 * area) / lineLength;
    }
}

5.3 内存管理与对象复用

JTS几何对象创建开销较大，特别是在高频调用的场景中，对象复用可以显著提升性能。

public class GeometryPool {
    
    private GeometryFactory factory;
    private Map<String, Geometry> geometryCache = new ConcurrentHashMap<>();
    
    public GeometryPool() {
        this.factory = new GeometryFactory();
    }
    
    /**
     * 获取或创建几何对象（带缓存）
     */
    public Geometry getGeometry(String wkt) {
        return geometryCache.computeIfAbsent(wkt, key -> {
            try {
                WKTReader reader = new WKTReader(factory);
                return reader.read(key);
            } catch (ParseException e) {
                throw new IllegalArgumentException("无效的WKT格式: " + key, e);
            }
        });
    }
    
    /**
     * 清空缓存
     */
    public void clearCache() {
        geometryCache.clear();
    }
    
    /**
     * 获取缓存的几何对象数量
     */
    public int getCacheSize() {
        return geometryCache.size();
    }
    
    /**
     * 使用对象池创建Coordinate（避免频繁创建小对象）
     */
    public Coordinate createCoordinate(double x, double y) {
        // 在实际项目中，可以使用更复杂的对象池实现
        return new Coordinate(x, y);
    }
    
    /**
     * 批量创建点（优化版本）
     */
    public Point[] createPoints(double[][] coordinates) {
        Point[] points = new Point[coordinates.length];
        
        for (int i = 0; i < coordinates.length; i++) {
            points[i] = factory.createPoint(
                new Coordinate(coordinates[i][0], coordinates[i][1]));
        }
        
        return points;
    }
}

5.4 错误处理与数据验证

在实际项目中，几何数据可能来自各种来源，质量参差不齐。良好的错误处理和数据验证机制至关重要。

public class GeometryValidator {
    
    /**
     * 验证WKT格式
     */
    public boolean isValidWKT(String wkt) {
        try {
            WKTReader reader = new WKTReader();
            reader.read(wkt);
            return true;
        } catch (ParseException e) {
            return false;
        }
    }
    
    /**
     * 验证几何对象是否有效
     */
    public boolean isValidGeometry(Geometry geometry) {
        return geometry.isValid();
    }
    
    /**
     * 修复无效的几何对象
     */
    public Geometry fixInvalidGeometry(Geometry geometry) {
        if (geometry.isValid()) {
            return geometry;
        }
        
        // 使用缓冲区为0的方法修复
        return geometry.buffer(0);
    }
    
    /**
     * 验证多边形是否闭合
     */
    public boolean isPolygonClosed(Polygon polygon) {
        LinearRing exterior = polygon.getExteriorRing();
        Coordinate[] coords = exterior.getCoordinates();
        
        if (coords.length < 4) {
            return false;
        }
        
        // 检查首尾点是否相同
        return coords[0].equals2D(coords[coords.length - 1]);
    }
    
    /**
     * 验证多边形是否为简单多边形（不自交）
     */
    public boolean isSimplePolygon(Polygon polygon) {
        return polygon.isSimple();
    }
    
    /**
     * 检查坐标是否在合理范围内（经纬度）
     */
    public boolean isValidCoordinate(double lng, double lat) {
        return lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90;
    }
    
    /**
     * 数据清洗：移除重复点、简化几何等
     */
    public Geometry cleanGeometry(Geometry geometry, double tolerance) {
        // 移除重复点
        Geometry uniquePoints = removeDuplicatePoints(geometry);
        
        // 简化几何
        Geometry simplified = simplify(uniquePoints, tolerance);
        
        // 修复拓扑错误
        return fixInvalidGeometry(simplified);
    }
    
    private Geometry removeDuplicatePoints(Geometry geometry) {
        // 实现移除重复点的逻辑
        return geometry;
    }
}

在物流配送系统的实际开发中，我遇到过因为几何数据质量问题导致的系统故障。一个供应商提供的配送范围多边形没有正确闭合，导致包含判断总是返回错误结果。后来我们建立了数据验证流程，所有入库的几何数据都要经过严格校验，问题才得到解决。

JTS的稳定性在长期运行的生产系统中得到了验证，但正确使用它需要理解其背后的原理和最佳实践。特别是在处理大规模数据时，合理的索引策略、几何简化和内存管理会让系统性能有质的提升。