Symfony中如何实现无显式命名的授权责任链服务调用

要实现统一的$this->chain->authorize($request)调用，你需要把分散的授权服务整合成自动流转的责任链，具体步骤如下：

1. 定义统一的授权处理器接口 #

先写一个接口，约束所有授权服务必须实现的方法——包括授权处理方法，以及设置下一个处理器的方法：

// src/Authorization/AuthorizationHandlerInterface.php
namespace App\Authorization;

use Symfony\Component\HttpFoundation\Request;

interface AuthorizationHandlerInterface
{
    // 处理授权逻辑
    public function authorize(Request $request): void;

    // 设置链中的下一个处理器
    public function setNext(AuthorizationHandlerInterface $handler): void;
}

2. 改造现有授权服务实现接口 #

把你的四个授权服务都改成实现这个接口，在authorize方法里先判断当前路由是否属于自己的处理范围，处理完成（或者不需要处理）后自动传递给下一个处理器。

举个示例（第一个授权服务）：

// src/Authorization/RouteSpecificAuthorization1.php
namespace App\Authorization;

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;

class RouteSpecificAuthorization1 implements AuthorizationHandlerInterface
{
    private ?AuthorizationHandlerInterface $nextHandler = null;

    public function authorize(Request $request): void
    {
        // 获取当前请求的路由
        $currentRoute = $request->attributes->get('_route');
        
        // 判断是否需要处理该路由
        if (in_array($currentRoute, ['app.user_profile', 'app.user_settings'])) {
            // 执行你的授权逻辑，比如检查用户权限
            if (!$this->hasUserAccess($request)) {
                throw new AccessDeniedException('你没有访问该页面的权限');
            }
        }

        // 如果有下一个处理器，传递请求过去
        if ($this->nextHandler) {
            $this->nextHandler->authorize($request);
        }
    }

    public function setNext(AuthorizationHandlerInterface $handler): void
    {
        $this->nextHandler = $handler;
    }

    // 自定义授权检查逻辑
    private function hasUserAccess(Request $request): bool
    {
        // 这里写你的具体判断，比如检查用户角色、是否拥有特定权限等
        return $this->getUser()->hasRole('ROLE_USER');
    }
}

另外三个授权服务（RouteSpecificAuthorization2/3/4）照这个结构改，只需要替换路由判断和授权逻辑即可。

3. 创建链管理器服务 #

这个服务是责任链的统一入口，负责把所有授权处理器串联起来，对外提供单一的authorize方法：

// src/Authorization/ChainAuthorization.php
namespace App\Authorization;

use Symfony\Component\HttpFoundation\Request;

class ChainAuthorization
{
    private AuthorizationHandlerInterface $firstHandler;

    // 方式一：手动指定第一个处理器（适合固定顺序的场景）
    public function __construct(AuthorizationHandlerInterface $firstHandler)
    {
        $this->firstHandler = $firstHandler;
    }

    // 方式二：自动收集所有处理器并串联（适合动态添加的场景）
    // public function __construct(private iterable $handlers)
    // {
    //     $this->linkHandlers();
    // }

    // private function linkHandlers(): void
    // {
    //     $handlerList = iterator_to_array($this->handlers);
    //     $totalHandlers = count($handlerList);
        
    //     for ($i = 0; $i < $totalHandlers - 1; $i++) {
    //         $handlerList[$i]->setNext($handlerList[$i + 1]);
    //     }
        
    //     $this->firstHandler = reset($handlerList);
    // }

    public function authorize(Request $request): void
    {
        $this->firstHandler->authorize($request);
    }
}

两种方式选一种：如果你的授权顺序是固定的，用方式一；如果以后可能要动态新增授权服务，用方式二更方便。

4. 配置Symfony服务 #

方式一：手动串联处理器（固定顺序） #

在config/services.yaml里配置，手动设置每个处理器的下一个节点：

services:
    # 注册四个授权服务
    App\Authorization\RouteSpecificAuthorization1: ~
    App\Authorization\RouteSpecificAuthorization2: ~
    App\Authorization\RouteSpecificAuthorization3: ~
    App\Authorization\RouteSpecificAuthorization4: ~

    # 配置链管理器，串联所有处理器
    App\Authorization\ChainAuthorization:
        arguments:
            $firstHandler: '@App\Authorization\RouteSpecificAuthorization1'
        calls:
            - method: setNext
              target: '@App\Authorization\RouteSpecificAuthorization1'
              arguments: ['@App\Authorization\RouteSpecificAuthorization2']
            - method: setNext
              target: '@App\Authorization\RouteSpecificAuthorization2'
              arguments: ['@App\Authorization\RouteSpecificAuthorization3']
            - method: setNext
              target: '@App\Authorization\RouteSpecificAuthorization3'
              arguments: ['@App\Authorization\RouteSpecificAuthorization4']

方式二：自动收集并串联 #

先给所有授权处理器打标签，让Symfony自动收集：

services:
    # 给所有实现AuthorizationHandlerInterface的服务自动打标签
    _instanceof:
        App\Authorization\AuthorizationHandlerInterface:
            tags: ['authorization.handler']

    # 配置链管理器，注入所有带标签的处理器
    App\Authorization\ChainAuthorization:
        arguments:
            # 注入所有带authorization.handler标签的服务，支持按priority排序
            $handlers: !tagged_iterator { tag: authorization.handler, default_priority: 0 }

然后把ChainAuthorization的构造函数改成方式二的版本（取消注释那段代码），容器会自动按优先级排序并串联所有处理器。

5. 使用统一的链授权 #

在需要授权的地方（比如控制器、事件监听器、Guard认证器等）注入ChainAuthorization，调用统一的方法即可：

// src/Controller/DashboardController.php
namespace App\Controller;

use App\Authorization\ChainAuthorization;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;

class DashboardController extends AbstractController
{
    public function index(Request $request, ChainAuthorization $chain): Response
    {
        // 统一调用链授权
        $chain->authorize($request);

        // 后续业务逻辑
        return $this->render('dashboard/index.html.twig');
    }
}

这样就可以用$chain->authorize($request)替代原来的显式链式调用，完全实现责任链模式的自动流转。

内容的提问来源于stack exchange，提问作者pma133