1
namespace app\model;
2

3
use think\Model;
4

5
class GatewayRoute extends Model
6
{
7
    protected $name = 'gateway_route';
8
    protected $autoWriteTimestamp = true;
9

10
    // 获取所有启用的路由
11
    public static function getActiveRoutes()
12
    {
13
        return self::where('status', 1)
14
            ->cache('active_routes', 60)
15
            ->select();
16
    }
17

18
    // 根据路径查找路由
19
    public static function findByPath($path)
20
    {
21
        return self::where('path', $path)
22
            ->where('status', 1)
23
            ->find();
24
    }
25
}
26

27
// app/model/ServiceInstance.php
28
namespace app\model;
29

30
use think\Model;
31

32
class ServiceInstance extends Model
33
{
34
    protected $name = 'service_instance';
35
    protected $autoWriteTimestamp = true;
36
    protected $json = ['metadata'];
37

38
    // 获取服务的健康实例
39
    public static function getHealthyInstances($serviceId)
40
    {
41
        return self::where('service_id', $serviceId)
42
            ->where('status', 1)
43
            ->where('last_heartbeat', '>=', date('Y-m-d H:i:s', time() - 30))
44
            ->order('weight', 'desc')
45
            ->select();
46
    }
47

48
    // 更新心跳时间
49
    public function updateHeartbeat()
50
    {
51
        $this->save(['last_heartbeat' => date('Y-m-d H:i:s')]);
52
    }
53
}

1
namespace app\gateway;
2

3
use think\facade\Cache;
4
use app\model\GatewayRoute;
5

6
class Router
7
{
8
    protected $routes = [];
9

10
    public function loadRoutes()
11
    {
12
        $this->routes = Cache::remember('gateway_routes', function() {
13
            $routes = GatewayRoute::getActiveRoutes();
14
            $routeMap = [];
15

16
            foreach ($routes as $route) {
17
                $routeMap[$route['path']] = $route->toArray();
18
            }
19

20
            return $routeMap;
21
        }, 60);
22
    }
23

24
    public function match($path)
25
    {
26
        // 精确匹配
27
        if (isset($this->routes[$path])) {
28
            return $this->routes[$path];
29
        }
30

31
        // 通配符匹配
32
        foreach ($this->routes as $routePath => $route) {
33
            if ($this->matchPattern($routePath, $path)) {
34
                return $route;
35
            }
36
        }
37

38
        return null;
39
    }
40

41
    private function matchPattern($pattern, $path)
42
    {
43
        if (strpos($pattern, '*') === false) {
44
            return false;
45
        }
46

47
        $regex = str_replace('*', '[^/]+', preg_quote($pattern, '#'));
48
        $regex = '#^' . $regex . '$#';
49

50
        return preg_match($regex, $path);
51
    }
52

53
    public function refresh()
54
    {
55
        Cache::delete('gateway_routes');
56
        $this->loadRoutes();
57
    }
58
}

1
namespace app\gateway;
2

3
use app\model\ServiceInstance;
4

5
class LoadBalancer
6
{
7
    const STRATEGY_RANDOM = 'random';
8
    const STRATEGY_ROUND_ROBIN = 'round_robin';
9
    const STRATEGY_WEIGHT = 'weight';
10

11
    protected $strategy;
12
    protected $currentIndex = [];
13

14
    public function __construct($strategy = self::STRATEGY_WEIGHT)
15
    {
16
        $this->strategy = $strategy;
17
    }
18

19
    public function chooseInstance($serviceId)
20
    {
21
        $instances = ServiceInstance::getHealthyInstances($serviceId);
22

23
        if (empty($instances)) {
24
            throw new Exception("No available instances for service: {$serviceId}");
25
        }
26

27
        switch ($this->strategy) {
28
            case self::STRATEGY_RANDOM:
29
                return $this->random($instances);
30
            case self::STRATEGY_ROUND_ROBIN:
31
                return $this->roundRobin($instances, $serviceId);
32
            case self::STRATEGY_WEIGHT:
33
                return $this->weighted($instances);
34
            default:
35
                return $this->weighted($instances);
36
        }
37
    }
38

39
    private function random($instances)
40
    {
41
        $index = array_rand($instances);
42
        return $instances[$index];
43
    }
44

45
    private function roundRobin($instances, $serviceId)
46
    {
47
        if (!isset($this->currentIndex[$serviceId])) {
48
            $this->currentIndex[$serviceId] = 0;
49
        }
50

51
        $instance = $instances[$this->currentIndex[$serviceId]];
52
        $this->currentIndex[$serviceId] =
53
            ($this->currentIndex[$serviceId] + 1) % count($instances);
54

55
        return $instance;
56
    }
57

58
    private function weighted($instances)
59
    {
60
        $totalWeight = 0;
61
        foreach ($instances as $instance) {
62
            $totalWeight += $instance['weight'];
63
        }
64

65
        $random = mt_rand(1, $totalWeight);
66
        $current = 0;
67

68
        foreach ($instances as $instance) {
69
            $current += $instance['weight'];
70
            if ($random <= $current) {
71
                return $instance;
72
            }
73
        }
74

75
        return $instances[0];
76
    }
77
}

1
namespace app\gateway;
2

3
use think\facade\Cache;
4
use think\facade\Request;
5

6
class RateLimiter
7
{
8
    protected $rules = [];
9

10
    public function check($routeId, $identifier = null)
11
    {
12
        $rules = $this->getRules($routeId);
13
        $identifier = $identifier ?: $this->getIdentifier();
14

15
        foreach ($rules as $rule) {
16
            if (!$this->checkRule($rule, $identifier)) {
17
                return false;
18
            }
19
        }
20

21
        return true;
22
    }
23

24
    private function getIdentifier()
25
    {
26
        // 根据限流类型获取标识符
27
        return Request::ip();
28
    }
29

30
    private function getRules($routeId)
31
    {
32
        if (!isset($this->rules[$routeId])) {
33
            $this->rules[$routeId] = Cache::remember(
34
                "rate_limit_rules:{$routeId}",
35
                function() use ($routeId) {
36
                    return app\model\RateLimitRule::where('route_id', $routeId)
37
                        ->where('status', 1)
38
                        ->select();
39
                },
40
                300
41
            );
42
        }
43

44
        return $this->rules[$routeId];
45
    }
46

47
    private function checkRule($rule, $identifier)
48
    {
49
        $key = $this->getCacheKey($rule, $identifier);
50
        $current = Cache::get($key, 0);
51

52
        if ($current >= $rule['limit_count']) {
53
            return false;
54
        }
55

56
        Cache::inc($key, 1);
57
        Cache::setTimeout($key, $rule['time_window']);
58

59
        return true;
60
    }
61

62
    private function getCacheKey($rule, $identifier)
63
    {
64
        $type = strtolower($rule['limit_type']);
65
        $window = time() / $rule['time_window'];
66

67
        return "rate_limit:{$type}:{$rule['route_id']}:{$identifier}:{$window}";
68
    }
69
}

1
namespace app\middleware;
2

3
use think\facade\Request;
4
use app\gateway\Router;
5
use app\gateway\LoadBalancer;
6
use app\gateway\RateLimiter;
7

8
class GatewayMiddleware
9
{
10
    protected $router;
11
    protected $loadBalancer;
12
    protected $rateLimiter;
13

14
    public function __construct()
15
    {
16
        $this->router = new Router();
17
        $this->loadBalancer = new LoadBalancer();
18
        $this->rateLimiter = new RateLimiter();
19
    }
20

21
    public function handle($request, Closure $next)
22
    {
23
        // 1. 路由匹配
24
        $route = $this->router->match($request->pathinfo());
25
        if (!$route) {
26
            return json(['code' => 404, 'msg' => 'Route not found']);
27
        }
28

29
        // 2. 限流检查
30
        if (!$this->rateLimiter->check($route['id'])) {
31
            return json(['code' => 429, 'msg' => 'Rate limit exceeded']);
32
        }
33

34
        // 3. 负载均衡选择实例
35
        try {
36
            $instance = $this->loadBalancer->chooseInstance($route['service_id']);
37
        } catch (Exception $e) {
38
            return json(['code' => 503, 'msg' => 'Service unavailable']);
39
        }
40

41
        // 4. 设置转发信息
42
        $request->gatewayRoute = $route;
43
        $request->targetInstance = $instance;
44

45
        return $next($request);
46
    }
47
}

1
namespace app\middleware;
2

3
use think\facade\Request;
4
use app\service\AuthService;
5

6
class AuthMiddleware
7
{
8
    protected $authService;
9

10
    public function __construct()
11
    {
12
        $this->authService = new AuthService();
13
    }
14

15
    public function handle($request, Closure $next)
16
    {
17
        $token = $request->header('Authorization');
18

19
        if (!$token) {
20
            return json(['code' => 401, 'msg' => 'Token required']);
21
        }
22

23
        try {
24
            $userInfo = $this->authService->verifyToken($token);
25
            $request->userInfo = $userInfo;
26
        } catch (Exception $e) {
27
            return json(['code' => 401, 'msg' => 'Invalid token']);
28
        }
29

30
        return $next($request);
31
    }
32
}

1
namespace app\service;
2

3
use think\facade\Db;
4
use app\model\ServiceInstance;
5

6
class RegistryService
7
{
8
    /**
9
     * 服务注册
10
     */
11
    public function register($serviceId, $instanceData)
12
    {
13
        $instance = ServiceInstance::where([
14
            'service_id' => $serviceId,
15
            'instance_id' => $instanceData['instance_id']
16
        ])->findOrEmpty();
17

18
        $instance->save(array_merge($instanceData, [
19
            'last_heartbeat' => date('Y-m-d H:i:s')
20
        ]));
21

22
        // 清除缓存
23
        $this->clearCache($serviceId);
24

25
        return true;
26
    }
27

28
    /**
29
     * 服务心跳
30
     */
31
    public function heartbeat($serviceId, $instanceId)
32
    {
33
        $instance = ServiceInstance::where([
34
            'service_id' => $serviceId,
35
            'instance_id' => $instanceId
36
        ])->find();
37

38
        if ($instance) {
39
            $instance->updateHeartbeat();
40
        }
41

42
        return true;
43
    }
44

45
    /**
46
     * 服务下线
47
     */
48
    public function deregister($serviceId, $instanceId)
49
    {
50
        ServiceInstance::where([
51
            'service_id' => $serviceId,
52
            'instance_id' => $instanceId
53
        ])->delete();
54

55
        $this->clearCache($serviceId);
56

57
        return true;
58
    }
59

60
    /**
61
     * 获取服务实例列表
62
     */
63
    public function getInstances($serviceId)
64
    {
65
        return ServiceInstance::getHealthyInstances($serviceId);
66
    }
67

68
    private function clearCache($serviceId)
69
    {
70
        // 清除相关缓存
71
        cache("service_instances:{$serviceId}", null);
72
    }
73
}

1
namespace app\service;
2

3
use think\facade\Db;
4

5
class ConfigService
6
{
7
    /**
8
     * 获取路由配置
9
     */
10
    public function getRouteConfig($routeId)
11
    {
12
        return Db::name('gateway_route')
13
            ->where('id', $routeId)
14
            ->find();
15
    }
16

17
    /**
18
     * 更新路由配置
19
     */
20
    public function updateRouteConfig($routeId, $data)
21
    {
22
        Db::name('gateway_route')
23
            ->where('id', $routeId)
24
            ->update($data);
25

26
        // 触发配置刷新
27
        event('RouteConfigUpdated', $routeId);
28

29
        return true;
30
    }
31

32
    /**
33
     * 获取限流规则
34
     */
35
    public function getRateLimitRules($routeId)
36
    {
37
        return Db::name('rate_limit_rule')
38
            ->where('route_id', $routeId)
39
            ->where('status', 1)
40
            ->select();
41
    }
42
}