很久沒有寫文章了,記錄一下這段時間學習的東西吧
laravel中間件是個很是方便的東西,能將一些邏輯實現解耦,而且在laravel中,
中間件的編寫也是很是的方便。誰用誰知道。php
laravel中的中間件使用的就是裝飾器模式,什麼是裝飾器模式,先去了解一下吧,這裏大概說一下,就是這個模式主要的就是用於解決 當一個類須要動態擴展功能的時候,使用繼承的方式會讓子類膨脹,而且這個擴展的功能是個公用功能的狀況下,不利於功能的複用以及代碼的解耦。html
在laravel,使用對於使用這種模式的功能,稱爲請求處理管道,也就是pipelinelaravel
//公共接口 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變量,它的值大概是這樣的 MiddleStepOne.handle(MiddleStepTwo.handle(first)),當執行的時候由於在handle中有個next()函數的存在,因此這是一個遞歸的調用。對於laravel的中間件,他的實現原理也是和這個同樣的。閉包
在laravel中,咱們咱們能夠經過設置中間件來在請求執行以前作一些預先的處理。app
從請求入口 public/index.php開始
重要的是這段代碼:即 處理請求,返回請求的響應
$response = $kernel->handle(框架
$request = Illuminate\Http\Request::capture() //建立一個請求實例
);模塊化
接着咱們進入kernel中看他的具體實現 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 = 'handle'; /** * 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 function carry()函數內部,對於當pip是閉包,字符串,還有對象的處理。
以前以爲laravel的中間件是個很神祕的東西,可是看了以後才以爲也就那樣,很精巧,在實際開發中這種模式也是頗有幫助的,例如咱們目前用的一個gateway項目,由於沒有使用任何框架,因此將判斷條件剝離,寫入到中間件中, 這樣實現了必定程度上的模塊化編程。