laravel5中对pipeline的理解

原文地址：laravel5中对pipeline的理解 http://sheefeng.com/laravel5-pipeline/

pipeline在laravel中的应用

Router和ControllerDispatcher中都用到了pipeline结构,具体如下所示:

router中的Pipeline:

/**
* Run the given route within a Stack "onion" instance.
*
* @param  \Illuminate\Routing\Route  $route
* @param  \Illuminate\Http\Request  $request
* @return mixed
*/
protected function runRouteWithinStack(Route $route, Request $request)
{
$middleware = $this->gatherRouteMiddlewares($route);

return (new Pipeline($this->container))
->send($request)
->through($middleware)
->then(function($request) use ($route)
{
return $this->prepareResponse(
$request,
$route->run($request)
);
});
}

ControllerDispatcher中的Pipeline:

/**
* Call the given controller instance method.
*
* @param  \Illuminate\Routing\Controller  $instance
* @param  \Illuminate\Routing\Route  $route
* @param  \Illuminate\Http\Request  $request
* @param  string  $method
* @return mixed
*/
protected function callWithinStack($instance, $route, $request, $method)
{
$middleware = $this->getMiddleware($instance, $method);

// Here we will make a stack onion instance to execute this request in, which gives
// us the ability to define middlewares on controllers. We will return the given
// response back out so that "after" filters can be run after the middlewares.
return (new Pipeline($this->container))
->send($request)
->through($middleware)
->then(function($request) use ($instance, $route, $method)
{
return $this->call($instance, $route, $method);
});
}

pipeline的存在主要是为了处理中间件逻辑.

router中的pipeline主要是首先运行选定某一个match到的route后,执行这个route所对应的的MiddleWare,最后执行这个route所对应的controller操作(在controller操作中,也会涉及到pipeline应用,如下).

ControllerDispatcher中的pipeline主要是运行Controller层面(已经选定了某个route以后)的MiddleWare,然后再最后执行controller中的具体操作($this->call($instance, $route, $method)).

理解pipeline,就要理解洋葱模型,像剥洋葱一样一层一层往里面剥.以下面语句为例:

(new Pipeline($this->container))
->send($passable)
->through($middleware)
->then($destination);

将容器$this->container注入pipeline,$passable这个变量一直在被传递,middleware数组代表要穿过的层,$destination一般是一个闭包函数,代表最终要执行的动作.

上述语句的含义就是携带着$passable这个变量,穿越层层MiddleWare,然后执行最后的$destination,如下所示:

pipeline的基本原理

下面再来看看pipeline的基本原理:

先看看pipeline的源码:

<?php namespace Illuminate\Pipeline;

use Closure;
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;
//要在洋葱模型中传递的变量,可以是一个Request对象

/**
* The array of class pipes.
*
* @var array
*/
protected $pipes = array();
//在洋葱模型中要经过的管道,一般是一些MiddleWare

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

/**
* Create a new class instance.
*
* @param  \Illuminate\Contracts\Container\Container  $container
* @return void
*/
public function __construct(Container $container)
{
$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  dynamic|array  $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)
{
$firstSlice = $this->getInitialSlice($destination);
//将passable变量和destination这个闭包结合起来,生成一个新的闭包为firstSlice

$pipes = array_reverse($this->pipes);

return call_user_func(
array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
);
//核心步骤
}

/**
* Get a Closure that represents a slice of the application onion.
*
* @return \Closure
*/
protected function getSlice()
{
return function($stack, $pipe)
{
return function($passable) use ($stack, $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.
if ($pipe instanceof Closure)
{
return call_user_func($pipe, $passable, $stack);
}
else
{
return $this->container->make($pipe)
->{$this->method}($passable, $stack);
}
};
};
}

/**
* Get the initial slice to begin the stack call.
*
* @param  \Closure  $destination
* @return \Closure
*/
//getInitialSlice()用来生成一个closure来实现$destination中的动作.
protected function getInitialSlice(Closure $destination)
{
return function($passable) use ($destination)
{
return call_user_func($destination, $passable);
};
}

}

上面的

return call_user_func(
array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
);

是核心步骤,不了解arrayreduce语法的人可以参考:http://php.net/manual/zh/function.array-reduce.php

getInitialSlice()用来生成一个closure来实现$destination中的动作.

getSlice()方法用来构造一个closure来不断的迭代pipes里面的每一个pipe

至于getSlice()方法中为何会向下面这样嵌套两个function,我的理解就是arrayreduce中的第二个参数是一个closure,这个closure只接受两个参数的closure,而我们这里有一个$Passable变量需要不断传递,所以需要在内部再加一层function嵌套.

return function($stack, $pipe)
{
return function($passable) use ($stack, $pipe)
{
/**中间内容忽略
};
};
}