借助CodeBuddy进行航道管理系统升级开发的那些事

@Mapper
public interface ShipTrackMapper extends BaseMapper<ShipTrack> {
    // 自定义批量插入方法，适配AIS数据高频写入场景
    @InsertProvider(type = ShipTrackProvider.class, method = "batchInsert")
    int batchInsert(@Param("list") List<ShipTrack> trackList);
}

// 实体类添加版本控制
@Data
@TableName("ship_track")
public class ShipTrack {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String mmsi; // 船舶识别码
    private BigDecimal longitude; // 经度
    private BigDecimal latitude; // 纬度
    @Version
    private Integer version; // 乐观锁版本号
}

// 第一步：GeoHash网格划分与存储
public void updateShipGrid(ShipDynamic ship) {
    String geoHash = GeoHashUtils.encode(ship.getLatitude(), ship.getLongitude(), 12); // 12位精度约500m
    redisTemplate.opsForSet().add("grid:" + geoHash, ship.getMmsi());
    // 设置过期时间，清理离线船舶
    redisTemplate.expire("grid:" + geoHash, 5, TimeUnit.SECONDS);
}

// 第二步：向量过滤与碰撞检测
public List<CollisionWarning> checkCollision(ShipDynamic targetShip) {
    List<CollisionWarning> warnings = new ArrayList<>();
    String targetHash = GeoHashUtils.encode(targetShip.getLatitude(), targetShip.getLongitude(), 12);
    // 获取相邻9个网格的船舶（避免边界遗漏）
    Set<String> nearbyGrids = GeoHashUtils.getNeighbors(targetHash);
    nearbyGrids.add(targetHash);
    
    for (String grid : nearbyGrids) {
        Set<String> mmsiSet = redisTemplate.opsForSet().members("grid:" + grid);
        if (mmsiSet == null) continue;
        for (String mmsi : mmsiSet) {
            if (mmsi.equals(targetShip.getMmsi())) continue;
            ShipDynamic otherShip = shipCache.get(mmsi);
            // 航向角过滤（差值<30°）
            if (Math.abs(targetShip.getCourse() - otherShip.getCourse()) > 30) continue;
            // 相对速度计算
            double relativeSpeed = calculateRelativeSpeed(targetShip, otherShip);
            // 距离计算（Haversine公式）
            double distance = GeoDistanceUtils.calculate(targetShip, otherShip);
            // 碰撞风险判断（距离<2km且预计相遇时间<5分钟）
            if (distance < 2000 && (distance / relativeSpeed) < 300) {
                warnings.add(new CollisionWarning(targetShip, otherShip, distance));
            }
        }
    }
    return warnings;
}

@XxlJob("buoyInspectionJob")
public ReturnT<String> execute(String param) throws Exception {
    // 获取分片参数
    ShardingUtil.ShardingVO shardingVO = ShardingUtil.getShardingVo();
    int shardIndex = shardingVO.getIndex(); // 当前分片索引（0-2）
    int shardTotal = shardingVO.getTotal(); // 总分片数（3）
    
    // 获取所有航标ID，按哈希值分片
    List<String> allBuoyIds = buoyService.getAllBuoyIds();
    List<String> assignedBuoyIds = allBuoyIds.stream()
            .filter(id -> Math.abs(id.hashCode() % shardTotal) == shardIndex)
            .collect(Collectors.toList());
    
    // 并发执行巡检任务（线程池控制并发量）
    ExecutorService executor = Executors.newFixedThreadPool(50);
    CompletionService<InspectionResult> completionService = new ExecutorCompletionService<>(executor);
    
    for (String buoyId : assignedBuoyIds) {
        // Redis抢占任务，避免重复执行（过期时间10秒）
        String lockKey = "inspect:lock:" + buoyId;
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(locked)) {
            completionService.submit(() -> inspectBuoy(buoyId));
        }
    }
    
    // 处理结果
    for (int i = 0; i < assignedBuoyIds.size(); i++) {
        Future<InspectionResult> future = completionService.take();
        InspectionResult result = future.get();
        // 存储巡检结果
        inspectionDao.insert(result);
    }
    executor.shutdown();
    return ReturnT.SUCCESS;
}

<template>
  <canvas ref="mapCanvas" @wheel="handleZoom" @mousemove="handlePan"></canvas>
</template>

<script setup>
import { ref, onMounted, watch } from 'vue';
import { getTileUrl } from './tileUtils';

const mapCanvas = ref(null);
const viewport = ref({
  zoom: 10,
  center: { lng: 118.5, lat: 32.0 },
  bounds: calculateBounds(10, { lng: 118.5, lat: 32.0 })
});
const worker = new Worker(new URL('./mapWorker.js', import.meta.url));

// 视口变化时加载瓦片
watch(viewport, (newVal) => {
  loadVisibleTiles(newVal);
}, { deep: true });

function loadVisibleTiles(viewport) {
  const tiles = calculateVisibleTiles(viewport); // 计算视口内瓦片ID
  tiles.forEach(tile => {
    fetch(getTileUrl(tile.x, tile.y, tile.z))
      .then(res => res.json())
      .then(geoJson => {
        // 发送到Web Worker解析
        worker.postMessage({ type: 'parse', data: geoJson });
      });
  });
}

// 接收Worker解析结果并渲染
worker.onmessage = (e) => {
  if (e.data.type === 'parsed') {
    renderFeatures(mapCanvas.value, e.data.features, viewport.value);
  }
};
</script>

self.onmessage = (e) => {
  if (e.data.type === 'parse') {
    const features = e.data.data.features;
    // 只保留视口内的要素
    const filtered = features.filter(f => isInViewport(f.geometry, e.data.viewport));
    // 简化几何图形（根据缩放级别）
    const simplified = filtered.map(f => simplifyGeometry(f, e.data.zoom));
    self.postMessage({ type: 'parsed', features: simplified });
  }
};