好久沒有寫文章了，記錄一下這段時間學習的東西吧
laravel中間件是個非常方便的東西，能將一些邏輯實現解耦，並且在laravel中，
中間件的編寫也是非常的方便。誰用誰知道。
- 裝飾器模式
laravel中的中間件使用的就是裝飾器模式，什麼是裝飾器模式，先去了解一下吧，這裏大概說一下，就是這個模式主要的就是用於解決 當一個類需要動態擴展功能的時候，使用繼承的方式會讓子類膨脹，並且這個擴展的功能是個公用功能的情況下，不利於功能的複用以及代碼的解耦。
在laravel，使用對於使用這種模式的功能，稱爲請求處理管道，也就是pipeline
//公共接口
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的中間件，他的實現原理也是和這個一樣的。
2.laravel中的中間件和請求處理管道
在laravel中，我們我們可以通過設置中間件來在請求執行之前做一些預先的處理。
從請求入口 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項目，因爲沒有使用任何框架，所以將判斷條件剝離，寫入到中間件中， 這樣實現了一定程度上的模塊化編程。