laravel框架的中間件middleware的詳解

時間 2019-11-05

標籤 laravel 框架中間件 middleware 詳解简体版

原文原文鏈接

本篇文章給你們帶來的內容是關於laravel框架的中間件middleware的詳解，有必定的參考價值，有須要的朋友能夠參考一下，但願對你有所幫助。php

laravel中間件是個很是方便的東西，能將一些邏輯實現解耦，而且在laravel中，
中間件的編寫也是很是的方便。誰用誰知道。laravel

1.裝飾器模式編程

laravel中的中間件使用的就是裝飾器模式，什麼是[裝飾器模式][1]，先去了解一下吧，這裏大概說一下，就是這個模式主要的就是用於解決當一個類須要動態擴展功能的時候，使用繼承的方式會讓子類膨脹，而且這個擴展的功能是個公用功能的狀況下，不利於功能的複用以及代碼的解耦。數組

在laravel，使用對於使用這種模式的功能，稱爲請求處理管道，也就是pipeline閉包

1app

2框架

3模塊化

4函數

5ui

//公共接口
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類了，

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

<?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;
    }
}