电子围栏功能设计与实现

1. 功能概述

电子围栏（Geofence）是一种基于地理位置的虚拟边界技术，通过GPS、WiFi、蓝牙等定位技术，在地图上设定虚拟的地理边界，当设备进入或离开这些区域时，系统会自动触发相应的事件和操作。

1.1 核心特性

• 多种围栏类型：支持圆形、多边形、矩形围栏
• 实时监控：设备位置实时跟踪和围栏状态监控
• 事件触发：进入/离开围栏自动触发告警或操作
• 灵活配置：支持动态创建、修改、删除围栏
• 多设备管理：同时监控多个设备的围栏状态

1.2 应用场景

• 车辆管理：车队管理、车辆防盗、行驶路线监控
• 人员安全：儿童安全、老人看护、员工考勤
• 资产管理：贵重物品防盗、设备位置监控
• 智慧城市：区域管控、环境监测、应急响应

2. 系统架构

graph TB
    A[移动设备/GPS终端] --> B[位置数据采集]
    B --> C[数据传输层]
    C --> D[位置服务网关]
    D --> E[围栏计算引擎]
    E --> F[事件处理器]
    F --> G[告警通知系统]
    E --> H[位置数据存储]
    I[围栏管理后台] --> J[围栏配置服务]
    J --> E
    K[实时监控大屏] --> L[数据可视化服务]
    L --> H

2.1 核心组件

位置数据采集层

• GPS定位模块
• WiFi定位辅助
• 基站定位补充
• 传感器融合定位

数据传输层

• MQTT协议传输
• HTTP/HTTPS接口
• WebSocket实时通信
• 数据压缩与加密

围栏计算引擎

• 地理围栏算法
• 实时位置判断
• 状态变化检测
• 性能优化处理

事件处理系统

• 事件规则引擎
• 告警策略配置
• 通知渠道管理
• 历史事件记录

3. 技术实现

3.1 围栏算法实现

圆形围栏判断

/**
 * 圆形围栏判断算法
 */
public class CircleGeofence {
    private double centerLat;    // 圆心纬度
    private double centerLng;    // 圆心经度
    private double radius;       // 半径（米）
    
    /**
     * 判断点是否在圆形围栏内
     * @param lat 纬度
     * @param lng 经度
     * @return true-在围栏内，false-在围栏外
     */
    public boolean isInside(double lat, double lng) {
        double distance = calculateDistance(centerLat, centerLng, lat, lng);
        return distance <= radius;
    }
    
    /**
     * 计算两点间距离（米）
     * 使用Haversine公式
     */
    private double calculateDistance(double lat1, double lng1, double lat2, double lng2) {
        final double R = 6371000; // 地球半径（米）
        
        double dLat = Math.toRadians(lat2 - lat1);
        double dLng = Math.toRadians(lng2 - lng1);
        
        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                   Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
                   Math.sin(dLng / 2) * Math.sin(dLng / 2);
        
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        
        return R * c;
    }
}

多边形围栏判断

/**
 * 多边形围栏判断算法
 * 使用射线法（Ray Casting Algorithm）
 */
public class PolygonGeofence {
    private List<Point> vertices; // 多边形顶点列表
    
    public static class Point {
        public double lat;
        public double lng;
        
        public Point(double lat, double lng) {
            this.lat = lat;
            this.lng = lng;
        }
    }
    
    /**
     * 判断点是否在多边形围栏内
     */
    public boolean isInside(double lat, double lng) {
        int intersectCount = 0;
        
        for (int i = 0; i < vertices.size(); i++) {
            Point p1 = vertices.get(i);
            Point p2 = vertices.get((i + 1) % vertices.size());
            
            if (rayIntersectsSegment(lat, lng, p1, p2)) {
                intersectCount++;
            }
        }
        
        // 奇数个交点表示在多边形内
        return (intersectCount % 2) == 1;
    }
    
    /**
     * 判断射线是否与线段相交
     */
    private boolean rayIntersectsSegment(double lat, double lng, Point p1, Point p2) {
        // 射线法实现细节
        if (p1.lat > lat != p2.lat > lat) {
            double intersectLng = (p2.lng - p1.lng) * (lat - p1.lat) / (p2.lat - p1.lat) + p1.lng;
            if (lng < intersectLng) {
                return true;
            }
        }
        return false;
    }
}

3.2 围栏服务实现

@Service
public class GeofenceService {
    
    @Autowired
    private GeofenceRepository geofenceRepository;
    
    @Autowired
    private DeviceLocationService deviceLocationService;
    
    @Autowired
    private EventNotificationService notificationService;
    
    /**
     * 检查设备位置与围栏状态
     */
    public void checkDeviceGeofenceStatus(String deviceId, double lat, double lng) {
        // 获取设备关联的所有围栏
        List<Geofence> geofences = geofenceRepository.findByDeviceId(deviceId);
        
        for (Geofence geofence : geofences) {
            boolean currentInside = isInsideGeofence(geofence, lat, lng);
            boolean previousInside = deviceLocationService.getPreviousGeofenceStatus(deviceId, geofence.getId());
            
            // 检查状态变化
            if (currentInside != previousInside) {
                GeofenceEvent event = new GeofenceEvent();
                event.setDeviceId(deviceId);
                event.setGeofenceId(geofence.getId());
                event.setEventType(currentInside ? EventType.ENTER : EventType.EXIT);
                event.setLatitude(lat);
                event.setLongitude(lng);
                event.setTimestamp(System.currentTimeMillis());
                
                // 触发事件处理
                handleGeofenceEvent(event);
                
                // 更新设备围栏状态
                deviceLocationService.updateGeofenceStatus(deviceId, geofence.getId(), currentInside);
            }
        }
    }
    
    /**
     * 判断位置是否在围栏内
     */
    private boolean isInsideGeofence(Geofence geofence, double lat, double lng) {
        switch (geofence.getType()) {
            case CIRCLE:
                CircleGeofence circle = new CircleGeofence(
                    geofence.getCenterLat(), 
                    geofence.getCenterLng(), 
                    geofence.getRadius()
                );
                return circle.isInside(lat, lng);
                
            case POLYGON:
                PolygonGeofence polygon = new PolygonGeofence(geofence.getVertices());
                return polygon.isInside(lat, lng);
                
            default:
                return false;
        }
    }
    
    /**
     * 处理围栏事件
     */
    private void handleGeofenceEvent(GeofenceEvent event) {
        // 保存事件记录
        saveGeofenceEvent(event);
        
        // 发送通知
        notificationService.sendGeofenceNotification(event);
        
        // 触发自定义规则
        executeCustomRules(event);
    }
}

3.3 实时位置处理

@Component
public class LocationProcessor {
    
    @Autowired
    private GeofenceService geofenceService;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 处理设备位置更新
     */
    @EventListener
    public void handleLocationUpdate(LocationUpdateEvent event) {
        String deviceId = event.getDeviceId();
        double lat = event.getLatitude();
        double lng = event.getLongitude();
        
        // 位置数据验证
        if (!isValidLocation(lat, lng)) {
            log.warn("Invalid location data for device: {}", deviceId);
            return;
        }
        
        // 缓存最新位置
        cacheDeviceLocation(deviceId, lat, lng);
        
        // 检查围栏状态
        geofenceService.checkDeviceGeofenceStatus(deviceId, lat, lng);
        
        // 更新位置历史
        updateLocationHistory(deviceId, lat, lng);
    }
    
    /**
     * 缓存设备位置
     */
    private void cacheDeviceLocation(String deviceId, double lat, double lng) {
        String key = "device:location:" + deviceId;
        Map<String, Object> location = new HashMap<>();
        location.put("latitude", lat);
        location.put("longitude", lng);
        location.put("timestamp", System.currentTimeMillis());
        
        redisTemplate.opsForHash().putAll(key, location);
        redisTemplate.expire(key, Duration.ofHours(24));
    }
    
    /**
     * 验证位置数据有效性
     */
    private boolean isValidLocation(double lat, double lng) {
        return lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180;
    }
}

4. 数据模型设计

4.1 围栏实体

@Entity
@Table(name = "geofence")
public class Geofence {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;                // 围栏名称
    
    @Column(nullable = false)
    private String description;         // 围栏描述
    
    @Enumerated(EnumType.STRING)
    private GeofenceType type;          // 围栏类型：CIRCLE, POLYGON, RECTANGLE
    
    @Column(name = "center_lat")
    private Double centerLat;           // 圆心纬度（圆形围栏）
    
    @Column(name = "center_lng")
    private Double centerLng;           // 圆心经度（圆形围栏）
    
    private Double radius;              // 半径（圆形围栏）
    
    @Column(columnDefinition = "TEXT")
    private String vertices;            // 顶点坐标（多边形围栏，JSON格式）
    
    @Enumerated(EnumType.STRING)
    private GeofenceStatus status;      // 围栏状态：ACTIVE, INACTIVE
    
    @Column(name = "created_time")
    private LocalDateTime createdTime;
    
    @Column(name = "updated_time")
    private LocalDateTime updatedTime;
    
    // 关联设备
    @ManyToMany
    @JoinTable(
        name = "device_geofence",
        joinColumns = @JoinColumn(name = "geofence_id"),
        inverseJoinColumns = @JoinColumn(name = "device_id")
    )
    private Set<Device> devices = new HashSet<>();
    
    // getter/setter省略
}

4.2 围栏事件实体

@Entity
@Table(name = "geofence_event")
public class GeofenceEvent {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "device_id", nullable = false)
    private String deviceId;
    
    @Column(name = "geofence_id", nullable = false)
    private Long geofenceId;
    
    @Enumerated(EnumType.STRING)
    private EventType eventType;        // ENTER, EXIT
    
    private Double latitude;
    private Double longitude;
    
    @Column(name = "event_time")
    private LocalDateTime eventTime;
    
    @Column(name = "processed")
    private Boolean processed = false;  // 是否已处理
    
    // getter/setter省略
}

5. API接口设计

5.1 围栏管理接口

@RestController
@RequestMapping("/api/geofence")
public class GeofenceController {
    
    @Autowired
    private GeofenceService geofenceService;
    
    /**
     * 创建围栏
     */
    @PostMapping
    public ResponseEntity<GeofenceDTO> createGeofence(@RequestBody @Valid CreateGeofenceRequest request) {
        GeofenceDTO geofence = geofenceService.createGeofence(request);
        return ResponseEntity.ok(geofence);
    }
    
    /**
     * 获取围栏列表
     */
    @GetMapping
    public ResponseEntity<PageResult<GeofenceDTO>> getGeofences(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) String keyword) {
        
        PageResult<GeofenceDTO> result = geofenceService.getGeofences(page, size, keyword);
        return ResponseEntity.ok(result);
    }
    
    /**
     * 获取围栏详情
     */
    @GetMapping("/{id}")
    public ResponseEntity<GeofenceDTO> getGeofence(@PathVariable Long id) {
        GeofenceDTO geofence = geofenceService.getGeofence(id);
        return ResponseEntity.ok(geofence);
    }
    
    /**
     * 更新围栏
     */
    @PutMapping("/{id}")
    public ResponseEntity<GeofenceDTO> updateGeofence(
            @PathVariable Long id, 
            @RequestBody @Valid UpdateGeofenceRequest request) {
        
        GeofenceDTO geofence = geofenceService.updateGeofence(id, request);
        return ResponseEntity.ok(geofence);
    }
    
    /**
     * 删除围栏
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteGeofence(@PathVariable Long id) {
        geofenceService.deleteGeofence(id);
        return ResponseEntity.ok().build();
    }
    
    /**
     * 绑定设备到围栏
     */
    @PostMapping("/{id}/devices")
    public ResponseEntity<Void> bindDevices(
            @PathVariable Long id, 
            @RequestBody List<String> deviceIds) {
        
        geofenceService.bindDevices(id, deviceIds);
        return ResponseEntity.ok().build();
    }
}

5.2 围栏事件接口

@RestController
@RequestMapping("/api/geofence/events")
public class GeofenceEventController {
    
    @Autowired
    private GeofenceEventService eventService;
    
    /**
     * 获取围栏事件列表
     */
    @GetMapping
    public ResponseEntity<PageResult<GeofenceEventDTO>> getEvents(
            @RequestParam(defaultValue = "1") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) String deviceId,
            @RequestParam(required = false) Long geofenceId,
            @RequestParam(required = false) EventType eventType,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startTime,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endTime) {
        
        GeofenceEventQuery query = GeofenceEventQuery.builder()
            .deviceId(deviceId)
            .geofenceId(geofenceId)
            .eventType(eventType)
            .startTime(startTime)
            .endTime(endTime)
            .build();
            
        PageResult<GeofenceEventDTO> result = eventService.getEvents(page, size, query);
        return ResponseEntity.ok(result);
    }
    
    /**
     * 获取设备当前围栏状态
     */
    @GetMapping("/device/{deviceId}/status")
    public ResponseEntity<List<DeviceGeofenceStatusDTO>> getDeviceGeofenceStatus(@PathVariable String deviceId) {
        List<DeviceGeofenceStatusDTO> status = eventService.getDeviceGeofenceStatus(deviceId);
        return ResponseEntity.ok(status);
    }
}

6. 前端实现

6.1 地图围栏绘制

// 基于高德地图的围栏绘制功能
class GeofenceMap {
    constructor(containerId) {
        this.map = new AMap.Map(containerId, {
            zoom: 13,
            center: [116.397428, 39.90923]
        });
        
        this.mouseTool = new AMap.MouseTool(this.map);
        this.geofences = [];
        this.initEvents();
    }
    
    /**
     * 绘制圆形围栏
     */
    drawCircle() {
        this.mouseTool.circle({
            fillColor: '#00b0ff',
            strokeColor: '#80d8ff',
            fillOpacity: 0.3,
            strokeWeight: 2
        });
    }
    
    /**
     * 绘制多边形围栏
     */
    drawPolygon() {
        this.mouseTool.polygon({
            fillColor: '#00b0ff',
            strokeColor: '#80d8ff',
            fillOpacity: 0.3,
            strokeWeight: 2
        });
    }
    
    /**
     * 初始化事件监听
     */
    initEvents() {
        // 监听绘制完成事件
        this.mouseTool.on('draw', (event) => {
            const overlay = event.obj;
            const geofenceData = this.extractGeofenceData(overlay);
            
            // 显示围栏配置对话框
            this.showGeofenceConfig(geofenceData, overlay);
        });
    }
    
    /**
     * 提取围栏数据
     */
    extractGeofenceData(overlay) {
        if (overlay.CLASS_NAME === 'AMap.Circle') {
            const center = overlay.getCenter();
            return {
                type: 'CIRCLE',
                centerLat: center.lat,
                centerLng: center.lng,
                radius: overlay.getRadius()
            };
        } else if (overlay.CLASS_NAME === 'AMap.Polygon') {
            const path = overlay.getPath();
            return {
                type: 'POLYGON',
                vertices: path.map(point => ({
                    lat: point.lat,
                    lng: point.lng
                }))
            };
        }
    }
    
    /**
     * 显示围栏配置对话框
     */
    showGeofenceConfig(geofenceData, overlay) {
        const dialog = new GeofenceConfigDialog({
            data: geofenceData,
            onSave: (config) => {
                this.saveGeofence(config, overlay);
            },
            onCancel: () => {
                this.map.remove(overlay);
            }
        });
        
        dialog.show();
    }
    
    /**
     * 保存围栏
     */
    async saveGeofence(config, overlay) {
        try {
            const response = await fetch('/api/geofence', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(config)
            });
            
            if (response.ok) {
                const geofence = await response.json();
                overlay.geofenceId = geofence.id;
                this.geofences.push({
                    id: geofence.id,
                    overlay: overlay,
                    config: config
                });
                
                this.$message.success('围栏创建成功');
            }
        } catch (error) {
            console.error('保存围栏失败:', error);
            this.$message.error('保存围栏失败');
            this.map.remove(overlay);
        }
    }
    
    /**
     * 加载已有围栏
     */
    async loadGeofences() {
        try {
            const response = await fetch('/api/geofence');
            const result = await response.json();
            
            result.data.forEach(geofence => {
                this.renderGeofence(geofence);
            });
        } catch (error) {
            console.error('加载围栏失败:', error);
        }
    }
    
    /**
     * 渲染围栏到地图
     */
    renderGeofence(geofence) {
        let overlay;
        
        if (geofence.type === 'CIRCLE') {
            overlay = new AMap.Circle({
                center: [geofence.centerLng, geofence.centerLat],
                radius: geofence.radius,
                fillColor: '#00b0ff',
                strokeColor: '#80d8ff',
                fillOpacity: 0.3,
                strokeWeight: 2
            });
        } else if (geofence.type === 'POLYGON') {
            const path = geofence.vertices.map(vertex => [vertex.lng, vertex.lat]);
            overlay = new AMap.Polygon({
                path: path,
                fillColor: '#00b0ff',
                strokeColor: '#80d8ff',
                fillOpacity: 0.3,
                strokeWeight: 2
            });
        }
        
        if (overlay) {
            overlay.geofenceId = geofence.id;
            this.map.add(overlay);
            
            // 添加点击事件
            overlay.on('click', () => {
                this.showGeofenceInfo(geofence);
            });
        }
    }
}

6.2 实时监控界面

<template>
  <div class="geofence-monitor">
    <!-- 地图容器 -->
    <div class="map-container">
      <div id="map" class="map"></div>
      
      <!-- 地图控制面板 -->
      <div class="map-controls">
        <el-button-group>
          <el-button @click="drawCircle" icon="el-icon-circle-plus">圆形围栏</el-button>
          <el-button @click="drawPolygon" icon="el-icon-s-grid">多边形围栏</el-button>
          <el-button @click="clearAll" icon="el-icon-delete">清除</el-button>
        </el-button-group>
      </div>
    </div>
    
    <!-- 侧边栏 -->
    <div class="sidebar">
      <!-- 围栏列表 -->
      <el-card class="geofence-list">
        <div slot="header">
          <span>围栏列表</span>
          <el-button style="float: right; padding: 3px 0" type="text" @click="refreshGeofences">刷新</el-button>
        </div>
        
        <el-table :data="geofences" size="small">
          <el-table-column prop="name" label="名称" width="120"></el-table-column>
          <el-table-column prop="type" label="类型" width="80">
            <template slot-scope="scope">
              <el-tag size="mini" :type="scope.row.type === 'CIRCLE' ? 'primary' : 'success'">
                {{ scope.row.type === 'CIRCLE' ? '圆形' : '多边形' }}
              </el-tag>
            </template>
          </el-table-column>
          <el-table-column prop="deviceCount" label="设备数" width="60"></el-table-column>
          <el-table-column label="操作" width="100">
            <template slot-scope="scope">
              <el-button size="mini" @click="editGeofence(scope.row)">编辑</el-button>
              <el-button size="mini" type="danger" @click="deleteGeofence(scope.row)">删除</el-button>
            </template>
          </el-table-column>
        </el-table>
      </el-card>
      
      <!-- 实时事件 -->
      <el-card class="event-list">
        <div slot="header">
          <span>实时事件</span>
        </div>
        
        <div class="event-item" v-for="event in realtimeEvents" :key="event.id">
          <div class="event-header">
            <span class="device-id">{{ event.deviceId }}</span>
            <span class="event-time">{{ formatTime(event.eventTime) }}</span>
          </div>
          <div class="event-content">
            <el-tag :type="event.eventType === 'ENTER' ? 'success' : 'warning'" size="mini">
              {{ event.eventType === 'ENTER' ? '进入' : '离开' }}
            </el-tag>
            <span class="geofence-name">{{ event.geofenceName }}</span>
          </div>
        </div>
      </el-card>
    </div>
  </div>
</template>

<script>
export default {
  name: 'GeofenceMonitor',
  data() {
    return {
      map: null,
      geofenceMap: null,
      geofences: [],
      realtimeEvents: [],
      websocket: null
    }
  },
  
  mounted() {
    this.initMap();
    this.loadGeofences();
    this.connectWebSocket();
  },
  
  beforeDestroy() {
    if (this.websocket) {
      this.websocket.close();
    }
  },
  
  methods: {
    /**
     * 初始化地图
     */
    initMap() {
      this.geofenceMap = new GeofenceMap('map');
    },
    
    /**
     * 绘制圆形围栏
     */
    drawCircle() {
      this.geofenceMap.drawCircle();
    },
    
    /**
     * 绘制多边形围栏
     */
    drawPolygon() {
      this.geofenceMap.drawPolygon();
    },
    
    /**
     * 清除所有围栏
     */
    clearAll() {
      this.$confirm('确认清除所有围栏？', '提示', {
        confirmButtonText: '确定',
        cancelButtonText: '取消',
        type: 'warning'
      }).then(() => {
        this.geofenceMap.clearAll();
      });
    },
    
    /**
     * 加载围栏列表
     */
    async loadGeofences() {
      try {
        const response = await this.$http.get('/api/geofence');
        this.geofences = response.data.data;
        
        // 在地图上显示围栏
        this.geofenceMap.loadGeofences();
      } catch (error) {
        this.$message.error('加载围栏失败');
      }
    },
    
    /**
     * 连接WebSocket获取实时事件
     */
    connectWebSocket() {
      const wsUrl = `ws://${location.host}/ws/geofence/events`;
      this.websocket = new WebSocket(wsUrl);
      
      this.websocket.onmessage = (event) => {
        const eventData = JSON.parse(event.data);
        this.handleRealtimeEvent(eventData);
      };
      
      this.websocket.onerror = (error) => {
        console.error('WebSocket连接错误:', error);
      };
    },
    
    /**
     * 处理实时事件
     */
    handleRealtimeEvent(eventData) {
      // 添加到事件列表
      this.realtimeEvents.unshift(eventData);
      
      // 保持最新50条事件
      if (this.realtimeEvents.length > 50) {
        this.realtimeEvents = this.realtimeEvents.slice(0, 50);
      }
      
      // 在地图上显示事件
      this.geofenceMap.showEventOnMap(eventData);
      
      // 显示通知
      this.$notify({
        title: '围栏事件',
        message: `设备 ${eventData.deviceId} ${eventData.eventType === 'ENTER' ? '进入' : '离开'} 围栏 ${eventData.geofenceName}`,
        type: eventData.eventType === 'ENTER' ? 'success' : 'warning',
        duration: 3000
      });
    },
    
    /**
     * 格式化时间
     */
    formatTime(timestamp) {
      return new Date(timestamp).toLocaleTimeString();
    }
  }
}
</script>

<style scoped>
.geofence-monitor {
  display: flex;
  height: 100vh;
}

.map-container {
  flex: 1;
  position: relative;
}

.map {
  width: 100%;
  height: 100%;
}

.map-controls {
  position: absolute;
  top: 10px;
  left: 10px;
  z-index: 1000;
}

.sidebar {
  width: 350px;
  background: #f5f5f5;
  padding: 10px;
  overflow-y: auto;
}

.geofence-list {
  margin-bottom: 10px;
}

.event-list {
  height: 400px;
  overflow-y: auto;
}

.event-item {
  padding: 8px;
  border-bottom: 1px solid #eee;
}

.event-header {
  display: flex;
  justify-content: space-between;
  margin-bottom: 4px;
}

.device-id {
  font-weight: bold;
}

.event-time {
  color: #999;
  font-size: 12px;
}

.event-content {
  display: flex;
  align-items: center;
  gap: 8px;
}

.geofence-name {
  color: #666;
}
</style>

7. 性能优化

7.1 算法优化

• 空间索引：使用R-tree或Quad-tree等空间索引结构，快速筛选可能相关的围栏
• 缓存机制：缓存围栏计算结果，避免重复计算
• 批量处理：对多个设备位置进行批量围栏检测
• 异步处理：围栏事件处理采用异步方式，避免阻塞主流程

7.2 数据库优化

-- 为围栏表创建空间索引
CREATE INDEX idx_geofence_location ON geofence 
USING GIST (ST_GeomFromText(CONCAT('POINT(', center_lng, ' ', center_lat, ')')));

-- 为事件表创建时间索引
CREATE INDEX idx_geofence_event_time ON geofence_event (event_time DESC);

-- 为设备ID创建索引
CREATE INDEX idx_geofence_event_device ON geofence_event (device_id, event_time DESC);

7.3 缓存策略

@Service
public class GeofenceCacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String GEOFENCE_CACHE_KEY = "geofence:";
    private static final String DEVICE_STATUS_KEY = "device:geofence:status:";
    
    /**
     * 缓存围栏信息
     */
    public void cacheGeofence(Geofence geofence) {
        String key = GEOFENCE_CACHE_KEY + geofence.getId();
        redisTemplate.opsForValue().set(key, geofence, Duration.ofHours(1));
    }
    
    /**
     * 获取缓存的围栏信息
     */
    public Geofence getCachedGeofence(Long geofenceId) {
        String key = GEOFENCE_CACHE_KEY + geofenceId;
        return (Geofence) redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 缓存设备围栏状态
     */
    public void cacheDeviceGeofenceStatus(String deviceId, Long geofenceId, boolean inside) {
        String key = DEVICE_STATUS_KEY + deviceId;
        redisTemplate.opsForHash().put(key, geofenceId.toString(), inside);
        redisTemplate.expire(key, Duration.ofDays(1));
    }
    
    /**
     * 获取设备围栏状态
     */
    public Boolean getDeviceGeofenceStatus(String deviceId, Long geofenceId) {
        String key = DEVICE_STATUS_KEY + deviceId;
        return (Boolean) redisTemplate.opsForHash().get(key, geofenceId.toString());
    }
}

8. 监控与告警

8.1 系统监控指标

• 位置更新频率：每秒处理的位置更新数量
• 围栏检测延迟：从位置更新到围栏状态判断的时间
• 事件处理延迟：从围栏事件产生到通知发送的时间
• 缓存命中率：围栏信息和设备状态的缓存命中率
• 错误率：位置数据错误、围栏计算错误的比例

8.2 告警配置

# 监控配置
monitoring:
  geofence:
    # 位置更新监控
    location-update:
      threshold: 1000  # 每秒处理数量阈值
      alert-delay: 30s # 告警延迟
    
    # 围栏检测延迟监控
    detection-latency:
      threshold: 5s    # 延迟阈值
      alert-delay: 60s
    
    # 错误率监控
    error-rate:
      threshold: 0.01  # 1%错误率阈值
      alert-delay: 300s

9. 部署与运维

9.1 Docker部署

# Dockerfile
FROM openjdk:11-jre-slim

VOLUME /tmp

COPY target/geofence-service.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "/app.jar"]

# docker-compose.yml
version: '3.8'

services:
  geofence-service:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - SPRING_DATASOURCE_URL=jdbc:mysql://mysql:3306/geofence
      - SPRING_REDIS_HOST=redis
    depends_on:
      - mysql
      - redis
    networks:
      - geofence-network
  
  mysql:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=root123
      - MYSQL_DATABASE=geofence
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - geofence-network
  
  redis:
    image: redis:6.2
    volumes:
      - redis-data:/data
    networks:
      - geofence-network

volumes:
  mysql-data:
  redis-data:

networks:
  geofence-network:
    driver: bridge

9.2 Kubernetes部署

# geofence-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: geofence-service
  labels:
    app: geofence-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: geofence-service
  template:
    metadata:
      labels:
        app: geofence-service
    spec:
      containers:
      - name: geofence-service
        image: geofence-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "k8s"
        - name: SPRING_DATASOURCE_URL
          value: "jdbc:mysql://mysql-service:3306/geofence"
        - name: SPRING_REDIS_HOST
          value: "redis-service"
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: geofence-service
spec:
  selector:
    app: geofence-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: LoadBalancer

10. 总结

电子围栏功能是物联网系统中的重要组成部分，通过本文档的设计和实现方案，可以构建一个高性能、可扩展的电子围栏系统。

10.1 核心优势

• 高精度定位：支持多种定位技术融合，提供精确的位置服务
• 实时响应：毫秒级围栏状态检测和事件触发
• 灵活配置：支持多种围栏类型和自定义规则
• 高可用性：分布式架构设计，支持水平扩展
• 易于集成：标准化API接口，便于第三方系统集成

10.2 应用前景

随着物联网技术的发展和5G网络的普及，电子围栏技术将在更多场景中得到应用，如智慧城市、智能交通、工业4.0等领域，为数字化转型提供重要的技术支撑。