Magento 2: Plugin antes / próximo / depois da interação

No Magento 2, quando você cria um plug-in "around"

public function aroundRenderResult(
    \Magento\Framework\Controller\ResultInterface $subject,
    \Closure $proceed,
    ResponseHttp $response
) {
    //...
    $proceed($response);
    //...      
}    

você pode prosseguir para o próximo plug-in, culminando em chamar o método original real, chamando / chamando o $proceedmétodo passado . Esse é um padrão de design comum, geralmente visto nas implementações de middleware do PHP Frameworks.

Contudo - apresenta alguma confusão w / r / t aos detalhes da implementação. Especificamente

Se, além de um aroundPlugin, um objeto / classe tem um beforeou afterplugin definido, quando é acionado em relação à cadeia de plugins?

ou seja, todos os métodos anteriores são acionados antes que qualquer método de plug-in em torno seja acionado? Ou será antes plugins única fogo antes da final, reais verdadeira incêndios método?

O problema específico que estou tentando rastrear é que não consigo conectar um plug-in ao método de despacho no controlador frontal do Magento 2 quando o Magento está no modo de cache de página inteira . O cache da página inteira opera por um plug-in que não chama $proceed($response). Eu tentei cavar parte do código em torno desses plugins e achei o sistema difícil de raciocinar sem saber como seus plugins se destinam.

ie - a descrição na página dev docs parece, nesta instância específica, imprecisa. Não está claro se a documentação está incorreta ou se é um bug recentemente introduzido, se é um caso de extrema importância ou se a configuração do meu plugin está errada.

Alguém sabe, por observação direta ou por conhecimento cultural, como essa priorização deve funcionar?

Os plug-ins são classificados primeiro pela ordem de classificação e depois pelo prefixo do método.

Exemplo: para o método com 3 plugins (PluginA, PluginB, PluginC) com os seguintes métodos e sortOrder:

• PluginA (sortOrder = 10)
  • beforeDispatch ()
  • afterDispatch ()
• PluginB (sortOrder = 20)
  • beforeDispatch ()
  • aroundDispatch ()
  • afterDispatch ()
• PluginC (sortOrder = 30):
  • beforeDispatch ()
  • aroundDispatch ()
  • afterDispatch ()

O fluxo de execução deve ser o seguinte:

• PluginA :: beforeDispatch ()
• PluginB :: beforeDispatch ()
• PluginB :: aroundDispatch ()
  • PluginC :: beforeDispatch ()
  • PluginC :: aroundDispatch ()
    • Ação :: dispatch ()
  • PluginC :: afterDispatch ()
• PluginB :: afterDispatch ()
• PluginA :: afterDispatch ()

No livro de receitas Magento 2:

Se houver vários plugins que estendem a mesma função original, eles serão executados na seguinte sequência:

• o plug-in anterior com o menor sortOrder
• o plugin around com o menor sortOrder
• outro antes de plugins (do menor para o maior sortOrder)
• outro em torno de plugins (do menor para o maior sortOrder)
• o plugin after com o mais alto sortOrder
• outro após plugins (do mais alto para o mais baixo sortOrder)

Para mim, deve funcionar como:

• se a ordem de classificação não for definida, seu equivalente a zero (e isso significa que a ordem real é indefinida)
• os plugins devem ser classificados por ordem

Se você revisar o código, \Magento\Framework\Interception\Interceptor::___callPlugins()poderá ver os plug-ins chamados em ordem de armazenados na $pluginInfovariável. Essas informações transmitidas do método gerado automaticamente em interceptores como

public function {method}()
{
    $pluginInfo = $this->pluginList->getNext($this->subjectType, '{method}');
    if (!$pluginInfo) {
        return parent::{method}();
    } else {
        return $this->___callPlugins('{method}', func_get_args(), $pluginInfo);
    }
}

Como você vê a \Magento\Framework\Interception\PluginListInterfaceinterface e a \Magento\Framework\Interception\PluginList\PluginListimplementação padrão responsáveis ​​pela classificação dos plugins. Consulte o método _inheritPlugins: 152

/**
 * Sort items
 *
 * @param array $itemA
 * @param array $itemB
 * @return int
 */
protected function _sort($itemA, $itemB)
{
    if (isset($itemA['sortOrder'])) {
        if (isset($itemB['sortOrder'])) {
            return $itemA['sortOrder'] - $itemB['sortOrder'];
        }
        return $itemA['sortOrder'];
    } elseif (isset($itemB['sortOrder'])) {
        return $itemB['sortOrder'];
    } else {
        return 1;
    }
} 

Para mim, essa função tem dois erros lógicos:

• return $itemB['sortOrder'];deveria ser return - $itemB['sortOrder'];
• return 1; deveria estar return 0;

Espero que ajude você.