鈃哥博客-文章详情

Hyperf 框架集成地理围栏功能

最后更新时间：2026-01-28 10:37:35

地理围栏

# 安装依赖
## 首先创建一个新的 Hyperf 项目并安装必要的包：
```php
composer create-project hyperf/hyperf geo-fence-api
cd geo-fence-api
composer require hyperf/database hyperf/validation
```
# 数据库迁移
## 创建地理围栏和位置点的数据表：
```php
<?php
// database/migrations/xxxxxx_create_geo_fences_table.php

use Hyperf\Database\Migrations\Migration;
use Hyperf\Database\Schema\Blueprint;
use Hyperf\Database\Schema\Schema;

class CreateGeoFencesTable extends Migration
{
    public function up()
    {
        Schema::create('geo_fences', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->enum('type', ['circle', 'polygon']);
            $table->geometry('geometry');
            $table->timestamps();
        });
        
        // 添加空间索引
        DB::statement('ALTER TABLE geo_fences ADD SPATIAL INDEX(geometry)');
    }

public function down()
    {
        Schema::dropIfExists('geo_fences');
    }
}
```
```php
<?php
// database/migrations/xxxxxx_create_locations_table.php

use Hyperf\Database\Migrations\Migration;
use Hyperf\Database\Schema\Blueprint;
use Hyperf\Database\Schema\Schema;

class CreateLocationsTable extends Migration
{
    public function up()
    {
        Schema::create('locations', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->point('point');
            $table->timestamps();
        });
        
        // 添加空间索引
        DB::statement('ALTER TABLE locations ADD SPATIAL INDEX(point)');
    }

public function down()
    {
        Schema::dropIfExists('locations');
    }
}
```
## 创建模型
```php
<?php
// app/Model/GeoFence.php

namespace App\Model;

use Hyperf\DbConnection\Model\Model;

class GeoFence extends Model
{
    protected $table = 'geo_fences';
    
    // 定义几何字段的访问器和修改器
    public function getGeometryAttribute($value)
    {
        return $this->fromWkb($value);
    }
    
    public function setGeometryAttribute($value)
    {
        $this->attributes['geometry'] = DB::raw("ST_GeomFromText('$value')");
    }
    
    // 辅助方法：从WKB格式转换为数组
    private function fromWkb($wkb)
    {
        // 这里简化处理，实际应用中可能需要使用更复杂的解析
        return $wkb;
    }
}
```
```php
<?php
// app/Model/Location.php

namespace App\Model;

use Hyperf\DbConnection\Model\Model;

class Location extends Model
{
    protected $table = 'locations';
    
    // 定义几何字段的访问器和修改器
    public function getPointAttribute($value)
    {
        return $this->fromWkb($value);
    }
    
    public function setPointAttribute($value)
    {
        $this->attributes['point'] = DB::raw("ST_GeomFromText('POINT({$value['lng']} {$value['lat']})')");
    }
    
    private function fromWkb($wkb)
    {
        // 简化处理，实际应用中可能需要解析WKB格式
        if (!$wkb) return null;
        
        // 这里使用MySQL的ST_AsText函数获取文本表示
        $result = DB::select(DB::raw("SELECT ST_AsText('$wkb') as text"));
        preg_match('/POINT$(.+?) (.+?)$/', $result[0]->text, $matches);
        
        if (count($matches) === 3) {
            return [
                'lng' => (float) $matches[1],
                'lat' => (float) $matches[2]
            ];
        }
        
        return null;
    }
}
```
## 创建服务层
```php
<?php
// app/Service/GeoFenceService.php

namespace App\Service;

use App\Model\GeoFence;
use App\Model\Location;
use Hyperf\DbConnection\Db;

class GeoFenceService
{
    /**
     * 创建圆形围栏
     */
    public function createCircleFence(string $name, float $lat, float $lng, float $radius): GeoFence
    {
        // 注意：radius单位为米，需要转换为度数
        $radiusInDegrees = $radius / 111320;
        
        return GeoFence::create([
            'name' => $name,
            'type' => 'circle',
            'geometry' => "POINT($lng $lat)",
            // 使用ST_Buffer创建圆形
            'geometry' => DB::raw("ST_Buffer(ST_GeomFromText('POINT($lng $lat)'), $radiusInDegrees)")
        ]);
    }
    
    /**
     * 创建多边形围栏
     */
    public function createPolygonFence(string $name, array $points): GeoFence
    {
        // 构建WKT格式的多边形
        $wktPoints = implode(', ', array_map(function($point) {
            return "{$point['lng']} {$point['lat']}";
        }, $points));
        
        // 确保多边形是闭合的（首尾点相同）
        $firstPoint = $points[0];
        if (end($points)['lng'] !== $firstPoint['lng'] || end($points)['lat'] !== $firstPoint['lat']) {
            $wktPoints .= ", {$firstPoint['lng']} {$firstPoint['lat']}";
        }
        
        $wkt = "POLYGON(($wktPoints))";
        
        return GeoFence::create([
            'name' => $name,
            'type' => 'polygon',
            'geometry' => DB::raw("ST_GeomFromText('$wkt')")
        ]);
    }
    
    /**
     * 检查点是否在围栏内
     */
    public function checkPointInFence(float $lat, float $lng, int $fenceId): bool
    {
        $count = GeoFence::where('id', $fenceId)
            ->whereRaw("ST_Contains(geometry, ST_GeomFromText('POINT($lng $lat)'))")
            ->count();
            
        return $count > 0;
    }
    
    /**
     * 查找点所在的所有围栏
     */
    public function findFencesByPoint(float $lat, float $lng): array
    {
        return GeoFence::select('id', 'name', 'type')
            ->whereRaw("ST_Contains(geometry, ST_GeomFromText('POINT($lng $lat)'))")
            ->get()
            ->toArray();
    }
    
    /**
     * 查找附近的围栏
     */
    public function findNearbyFences(float $lat, float $lng, float $radius = 5000): array
    {
        // radius单位为米，转换为度数
        $radiusInDegrees = $radius / 111320;
        
        return GeoFence::select(
                'id', 
                'name', 
                'type',
                DB::raw("ST_Distance_Sphere(ST_Centroid(geometry), ST_GeomFromText('POINT($lng $lat)')) as distance")
            )
            ->whereRaw("ST_DWithin(geometry, ST_GeomFromText('POINT($lng $lat)'), $radiusInDegrees)")
            ->orderBy('distance')
            ->get()
            ->toArray();
    }
    
    /**
     * 创建位置点
     */
    public function createLocation(string $name, float $lat, float $lng): Location
    {
        return Location::create([
            'name' => $name,
            'point' => [
                'lat' => $lat,
                'lng' => $lng
            ]
        ]);
    }
    
    /**
     * 计算两点之间的距离
     */
    public function calculateDistance(float $lat1, float $lng1, float $lat2, float $lng2): float
    {
        $result = DB::select(DB::raw("
            SELECT ST_Distance_Sphere(
                ST_GeomFromText('POINT($lng1 $lat1)'),
                ST_GeomFromText('POINT($lng2 $lat2)')
            ) as distance
        "));
        
        return (float) $result[0]->distance;
    }
}
```
## 创建控制器
```php
<?php
// app/Controller/GeoFenceController.php

namespace App\Controller;

use App\Service\GeoFenceService;
use Hyperf\HttpServer\Annotation\Controller;
use Hyperf\HttpServer\Annotation\GetMapping;
use Hyperf\HttpServer\Annotation\PostMapping;
use Hyperf\HttpServer\Contract\RequestInterface;
use Hyperf\HttpServer\Contract\ResponseInterface;
use Hyperf\Validation\Contract\ValidatorFactoryInterface;

/**
 * @Controller(prefix="/geo-fence")
 */
class GeoFenceController
{
    private $geoFenceService;
    private $validatorFactory;

public function __construct(GeoFenceService $geoFenceService, ValidatorFactoryInterface $validatorFactory)
    {
        $this->geoFenceService = $geoFenceService;
        $this->validatorFactory = $validatorFactory;
    }
    
    /**
     * @PostMapping(path="/circle")
     */
    public function createCircle(RequestInterface $request, ResponseInterface $response)
    {
        $validator = $this->validatorFactory->make(
            $request->all(),
            [
                'name' => 'required|string',
                'lat' => 'required|numeric|between:-90,90',
                'lng' => 'required|numeric|between:-180,180',
                'radius' => 'required|numeric|min:1'
            ]
        );
        
        if ($validator->fails()) {
            return $response->json([
                'code' => 400,
                'message' => $validator->errors()->first()
            ]);
        }
        
        $fence = $this->geoFenceService->createCircleFence(
            $request->input('name'),
            $request->input('lat'),
            $request->input('lng'),
            $request->input('radius')
        );
        
        return $response->json([
            'code' => 200,
            'data' => $fence
        ]);
    }
    
    /**
     * @PostMapping(path="/polygon")
     */
    public function createPolygon(RequestInterface $request, ResponseInterface $response)
    {
        $validator = $this->validatorFactory->make(
            $request->all(),
            [
                'name' => 'required|string',
                'points' => 'required|array|min:3',
                'points.*.lat' => 'required|numeric|between:-90,90',
                'points.*.lng' => 'required|numeric|between:-180,180'
            ]
        );
        
        if ($validator->fails()) {
            return $response->json([
                'code' => 400,
                'message' => $validator->errors()->first()
            ]);
        }
        
        $fence = $this->geoFenceService->createPolygonFence(
            $request->input('name'),
            $request->input('points')
        );
        
        return $response->json([
            'code' => 200,
            'data' => $fence
        ]);
    }
    
    /**
     * @GetMapping(path="/check-point")
     */
    public function checkPoint(RequestInterface $request, ResponseInterface $response)
    {
        $validator = $this->validatorFactory->make(
            $request->all(),
            [
                'lat' => 'required|numeric|between:-90,90',
                'lng' => 'required|numeric|between:-180,180',
                'fence_id' => 'required|integer|exists:geo_fences,id'
            ]
        );
        
        if ($validator->fails()) {
            return $response->json([
                'code' => 400,
                'message' => $validator->errors()->first()
            ]);
        }
        
        $result = $this->geoFenceService->checkPointInFence(
            $request->input('lat'),
            $request->input('lng'),
            $request->input('fence_id')
        );
        
        return $response->json([
            'code' => 200,
            'data' => [
                'inside' => $result
            ]
        ]);
    }
    
    /**
     * @GetMapping(path="/nearby")
     */
    public function nearbyFences(RequestInterface $request, ResponseInterface $response)
    {
        $validator = $this->validatorFactory->make(
            $request->all(),
            [
                'lat' => 'required|numeric|between:-90,90',
                'lng' => 'required|numeric|between:-180,180',
                'radius' => 'numeric|min:1|max:100000'
            ]
        );
        
        if ($validator->fails()) {
            return $response->json([
                'code' => 400,
                'message' => $validator->errors()->first()
            ]);
        }
        
        $radius = $request->input('radius', 5000); // 默认5公里
        
        $fences = $this->geoFenceService->findNearbyFences(
            $request->input('lat'),
            $request->input('lng'),
            $radius
        );
        
        return $response->json([
            'code' => 200,
            'data' => $fences
        ]);
    }
    
    /**
     * @PostMapping(path="/location")
     */
    public function createLocation(RequestInterface $request, ResponseInterface $response)
    {
        $validator = $this->validatorFactory->make(
            $request->all(),
            [
                'name' => 'required|string',
                'lat' => 'required|numeric|between:-90,90',
                'lng' => 'required|numeric|between:-180,180',
            ]
        );
        
        if ($validator->fails()) {
            return $response->json([
                'code' => 400,
                'message' => $validator->errors()->first()
            ]);
        }
        
        $location = $this->geoFenceService->createLocation(
            $request->input('name'),
            $request->input('lat'),
            $request->input('lng')
        );
        
        return $response->json([
            'code' => 200,
            'data' => $location
        ]);
    }
    
    /**
     * @GetMapping(path="/distance")
     */
    public function calculateDistance(RequestInterface $request, ResponseInterface $response)
    {
        $validator = $this->validatorFactory->make(
            $request->all(),
            [
                'lat1' => 'required|numeric|between:-90,90',
                'lng1' => 'required|numeric|between:-180,180',
                'lat2' => 'required|numeric|between:-90,90',
                'lng2' => 'required|numeric|between:-180,180',
            ]
        );
        
        if ($validator->fails()) {
            return $response->json([
                'code' => 400,
                'message' => $validator->errors()->first()
            ]);
        }
        
        $distance = $this->geoFenceService->calculateDistance(
            $request->input('lat1'),
            $request->input('lng1'),
            $request->input('lat2'),
            $request->input('lng2')
        );
        
        return $response->json([
            'code' => 200,
            'data' => [
                'distance' => $distance,
                'unit' => 'meters'
            ]
        ]);
    }
}
```
# 配置数据库连接
## 确保.env文件中配置了正确的数据库连接信息：
```php
DB_DRIVER=mysql
DB_HOST=localhost
DB_PORT=3306
DB_DATABASE=geofence_db
DB_USERNAME=root
DB_PASSWORD=your_password
DB_CHARSET=utf8mb4
DB_COLLATION=utf8mb4_unicode_ci
DB_PREFIX=
```
# 性能优化建议
1. 连接池配置：在config/autoload/database.php中配置连接池，提高数据库访问效率：
```php
'pool' => [
    'min_connections' => 1,
    'max_connections' => 10,
    'connect_timeout' => 10.0,
    'wait_timeout' => 3.0,
    'heartbeat' => -1,
    'max_idle_time' => (float) env('DB_MAX_IDLE_TIME', 60),
],
```
2. 空间索引：确保在几何字段上创建了空间索引，提高查询性能。
3. 缓存机制：对于频繁查询的围栏数据，可以添加缓存层：
```php
// 在GeoFenceService中添加缓存逻辑
public function findFencesByPoint(float $lat, float $lng): array
{
    $cacheKey = "fences:point:{$lat}:{$lng}";
    
    return Cache::remember($cacheKey, 3600, function() use ($lat, $lng) {
        return GeoFence::select('id', 'name', 'type')
            ->whereRaw("ST_Contains(geometry, ST_GeomFromText('POINT($lng $lat)'))")
            ->get()
            ->toArray();
    });
}
```
这个实现充分利用了 Hyperf 的协程特性和 MySQL 的空间扩展功能，可以高效地处理地理围栏相关的查询和计算。你可以根据实际需求进一步扩展和优化这些代码。

Hyperf 框架集成地理围栏功能

留言条数·0