Laravelフレームワークのミドルウェアの詳細説明

この記事は、laravel フレームワークのミドルウェアについて詳しく説明しています。必要な方は参考にしていただければ幸いです。

Laravel ミドルウェアは非常に便利なもので、いくつかのロジック実装を分離できます。また、laravel では、
ミドルウェアの作成も非常に便利です。誰が誰だか知っています。

1. デコレータ モード

laravel のミドルウェアはデコレータ モードを使用します[1]。まずはそれについて学びましょう。このモデルは主に問題を解決するために使用されます。クラスが関数を動的に拡張する必要がある場合、継承を使用するとサブクラスが拡張され、拡張された関数は問題の再利用に役立ちません。そしてコードのデカップリング。

laravel では、このモードを使用する関数はリクエスト処理パイプラインと呼ばれ、パイプライン

//公共接口
interface middleware {
        public static function handle(Closure $next);
    }
//装饰器1
class MiddleStepOne implements middleware{
        public static function handle(Closure $next) {
            echo "前期处理的第一步"."<br>";
            $next();
            echo "后期处理的第一步"."<br>";
        }
    }
//装饰器2
class MiddleStepTwo implements middleware{
    public static function handle(Closure $next) {
        echo "前期处理的第二步"."<br>";
        $next();
        echo "后期处理的第二步"."<br>";
    }
}

function goFunc() {
    return function ($step,$className) {
      return function () use ($step,$className) {
          return $className::handle($step);
      };
    };
}

$pip = array(
    MiddleStepOne::class,
    MiddleStepTwo::class,
);
$pip = array_reverse($pip);  //反转数组，以求达到要求的顺序运行
$first = function (){
    echo "前期处理完毕"."<br>";
};  //实际要处理的函数
$a = array_reduce($pip,goFunc(),$first); //遍历pip数组，并将first作为第一个参数传递进去
$a(); //执行

出力:

#これは、デコレータ パターンに基づく単純なパイプラインです。その本質は実際にはクロージャと再帰に基づいています。

このプログラムを解析すると、最終的に生成された $a 変数は、handle に next() 関数が存在するため、実行時の値はおそらく MiddleStepOne.handle(MiddleStepTwo.handle(first)) のようになるでしょう。 , したがって、これは再帰呼び出しです。 laravelのミドルウェアも実装原理はこれと同じです。

2. laravel のミドルウェアとリクエスト処理パイプライン

laravel では、ミドルウェアを設定することでリクエストの実行前にいくつかの前処理を行うことができます。

リクエストの入り口 public/index.php から開始

##重要なのはこのコード、つまり処理です。リクエスト、リクエストに対するレスポンスを返します

$response = $kernel->handle(
$request = Illuminate\Http\Request::capture() //创建一个请求实例
);

次に、カーネルに入り、IlluminateFoundationHttpKernel.php

# でその特定の実装を確認します。

#dispatchToRouter() 関数についてはご自身でお読みください。ここでは詳しく説明しません。 次のステップは、興味深い PipeLine クラスです。

<?php namespace Illuminate\Pipeline;

use Closure;
use RuntimeException;
use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Pipeline\Pipeline as PipelineContract;

class Pipeline implements PipelineContract
{
    /**
     * The container implementation.
     *
     * @var \Illuminate\Contracts\Container\Container
     */
    protected $container;

    /**
     * The object being passed through the pipeline.
     *
     * @var mixed
     */
    protected $passable;

    /**
     * The array of class pipes.
     *
     * @var array
     */
    protected $pipes = [];

    /**
     * The method to call on each pipe.
     *
     * @var string
     */
    protected $method = &#39;handle&#39;;

    /**
     * Create a new class instance.
     *
     * @param  \Illuminate\Contracts\Container\Container|null  $container
     * @return void
     */
    public function __construct(Container $container = null)
    {
        $this->container = $container;
    }

    /**
     * Set the object being sent through the pipeline.
     *
     * @param  mixed  $passable
     * @return $this
     */
    public function send($passable)
    {
        $this->passable = $passable;

        return $this;
    }

    /**
     * Set the array of pipes.
     *
     * @param  array|mixed  $pipes
     * @return $this
     */
    public function through($pipes)
    {
        $this->pipes = is_array($pipes) ? $pipes : func_get_args();

        return $this;
    }

    /**
     * Set the method to call on the pipes.
     *
     * @param  string  $method
     * @return $this
     */
    public function via($method)
    {
        $this->method = $method;

        return $this;
    }

    /**
     * Run the pipeline with a final destination callback.
     *
     * @param  \Closure  $destination
     * @return mixed
     */
    public function then(Closure $destination)
    {
        $pipeline = array_reduce(
            array_reverse($this->pipes), $this->carry(), $this->prepareDestination($destination)
        );

        return $pipeline($this->passable);
    }

    /**
     * Get the final piece of the Closure onion.
     *
     * @param  \Closure  $destination
     * @return \Closure
     */
    protected function prepareDestination(Closure $destination)
    {
        return function ($passable) use ($destination) {
            return $destination($passable);
        };
    }

    /**
     * Get a Closure that represents a slice of the application onion.
     *
     * @return \Closure
     */
    protected function carry()
    {
        return function ($stack, $pipe) {
            return function ($passable) use ($stack, $pipe) {
                if (is_callable($pipe)) {
                    // If the pipe is an instance of a Closure, we will just call it directly but
                    // otherwise we'll resolve the pipes out of the container and call it with
                    // the appropriate method and arguments, returning the results back out.
                    //如果pip也就中间件函数是一个闭包可调用函数，就直接返回这个闭包函数就行了
                    //这里我还没有找到对应的使用场景，后续补充
                    return $pipe($passable, $stack);
                } elseif (! is_object($pipe)) {
                    list($name, $parameters) = $this->parsePipeString($pipe);

                    // If the pipe is a string we will parse the string and resolve the class out
                    // of the dependency injection container. We can then build a callable and
                    // execute the pipe function giving in the parameters that are required.
                    $pipe = $this->getContainer()->make($name);

                    $parameters = array_merge([$passable, $stack], $parameters);
                } else {
                    // If the pipe is already an object we'll just make a callable and pass it to
                    // the pipe as-is. There is no need to do any extra parsing and formatting
                    // since the object we're given was already a fully instantiated object.
                    $parameters = [$passable, $stack];
                }

                return method_exists($pipe, $this->method)
                                ? $pipe->{$this->method}(...$parameters)
                                : $pipe(...$parameters);
            };
        };
    }

    /**
     * Parse full pipe string to get name and parameters.
     *
     * @param  string $pipe
     * @return array
     */
    protected function parsePipeString($pipe)
    {
        list($name, $parameters) = array_pad(explode(':', $pipe, 2), 2, []);

        if (is_string($parameters)) {
            $parameters = explode(',', $parameters);
        }

        return [$name, $parameters];
    }

    /**
     * Get the container instance.
     *
     * @return \Illuminate\Contracts\Container\Container
     * @throws \RuntimeException
     */
    protected function getContainer()
    {
        if (! $this->container) {
            throw new RuntimeException('A container instance has not been passed to the Pipeline.');
        }

        return $this->container;
    }
}

一般に、pipeLine クラスの実装は、以前に書いたデコレータと似ています。ここでの主な問題は、

# ということです。 ##protected 関数 carry() 関数内では、pip の処理はクロージャ、文字列、オブジェクトです。

Laravel のミドルウェアはとても不思議なものだと思っていましたが、読んでみるとそのとおりで、実際の開発でも非常に役立つモデルであることがわかりました。たとえば、現在はゲートウェイプロジェクトを使用しています。フレームワークを使用していないため、判定条件を取り除いてミドルウェアに書き込むことで、ある程度のモジュール化されたプログラミングを実現しています。

以上がLaravelフレームワークのミドルウェアの詳細説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。