Lavavel5.5源代码 - Pipeline

<?php

class Pipeline
{

    protected $passable;
    protected $pipes = [];
    protected $method = 'handle';

    public function send($passable)
    {
        $this->passable = $passable;

        return $this;
    }

    public function through($pipes)
    {
        $this->pipes = is_array($pipes) ? $pipes : func_get_args();

        return $this;
    }

    public function then(\Closure $destination)
    {
        $pipeline = array_reduce(
            array_reverse($this->pipes), $this->carry(), $this->prepareDestination($destination)
        );

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

    protected function prepareDestination(Closure $destination)
    {
        return function ($passable) use ($destination) {
            return $destination($passable);
        };
    }

    protected function carry()
    {
        return function ($stack, $pipe) { // $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.
                    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);
                    $pipe = new $pipe;
                    $parameters = array_merge([$passable, $stack], []);
                } 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);
            };
        };
    }

}

class FooOneMiddleware
{
    public function handle($request, \Closure $next)
    {
        echo __METHOD__.":".$request.PHP_EOL;
        return $next($request);
    }
}

class FooTwoMiddleware
{
    public function handle($request, \Closure $next)
    {
        echo __METHOD__.":".$request.PHP_EOL;
        return $next($request);
    }
}

/*
    function array_reduce($array, $callback, $initial=null)
    {
        $acc = $initial;
        foreach($array as $a){
            $acc = $callback($acc, $a);
        }
        return $acc;
    }
 */
{
    $middleware = [
        FooOneMiddleware::class,
        FooTwoMiddleware::class
    ];
    $then = function () {
        return 'this is output...'.PHP_EOL;
    };
    $result = (new Pipeline())
        ->send('this is input')
        ->through($middleware)
        ->then($then);
    echo $result;
}