精华内容
下载资源
问答
  • laravel 创建中间件

    2018-12-25 15:46:22
    创建中间件 php artisan make:middleware LoginSession 在 Kemel.php 文件中中间件添加到局部中间件中,如下例: protected $routeMiddleware = [ 'auth' => \App\Http\Middleware\Authenticate::class, ...
        创建中间件 php artisan make:middleware LoginSession
    在 Kemel.php 文件中中间件添加到局部中间件中,如下例:
     
         protected $routeMiddleware = [
             'auth' => \App\Http\Middleware\Authenticate::class,
             'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
             'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
             //添加的中间件 Admin
             'Admin' => \App\Http\Middleware\LoginSession::class,
         ];
    

     

    展开全文
  • laravel中间件创建思路

    万次阅读 2020-03-28 16:24:16
    网上有很多解析laravel中间件的实现原理,但是不知道有没有读者在读的时候不明白,作者是怎么想到要用array_reduce函数的? 本文从自己的角度出发,模拟了如果我是作者,我是怎么实现这个中间件功能,又是怎么找到并...

    网上有很多解析laravel中间件的实现原理,但是不知道有没有读者在读的时候不明白,作者是怎么想到要用array_reduce函数的?

    本文从自己的角度出发,模拟了如果我是作者,我是怎么实现这个中间件功能,又是怎么找到并使用对应的函数。

    什么是laravel中间件

    Laravel 中间件提供了一种机制在不修改逻辑代码的情况下,中断原本程序流程,通过中间件来处理一些事件,或者扩展一些功能。比如日志中间件可以方便的记录请求和响应日志,而不需要去更改逻辑代码。

    那么我们简化一下软件执行过程,现在有一个核心类kernel,下面是它的laravel代码

    #捕获请求
    $request = Illuminate\Http\Request::capture()
    #处理请求
    $response = $kernel->handle($request);
    

    代码的作用是 捕获一个 Request ,返回一个 Response。这里面就是后续分发到具体执行逻辑的代码段并返回结果。

    那么如果想在执行这个$kernel->handle()方法之前或者之后,增加一段逻辑一般会怎么写呢。大概如下:

    $request = Illuminate\Http\Request::capture()
    
    function midware(){
        before()#在之前执行的语句集合
        #####    
        $response = $kernel->handle($request);
        #####
        after()#在之后执行的语句集合
    }
    

    显然这样写没有问题,但是毫无拓展性可言,想执行什么东西都要更改这个方法,这种是不可能封装成框架核心内容的。怎么改进呢

    定义一个要执行的中间件类叫middleware,类实现两个方法,before()和after()然后代码如下。

    #配置项中有一项配置中间件:
    middleware = '';
    
    $request = Illuminate\Http\Request::capture()
    
    function midware(){
        middleware.before()
        #####    
        $response = $kernel->handle($request);
        #####
        middleware.after()
    }
    

    是否解决了问题呢,是解决了不用更改的问题,但是我们如果需要多个中间件怎么办呢,最容易想到的就是:定义一个中间件数组middleware_arr,每一个middleware类都含有before和after方法,代码如下:

    #配置项中有middleware_arr
    middleware_arr=array();
    
    $request = Illuminate\Http\Request::capture()
    
    function midware(){
        foreach(middleware_arr as middleware){
           middleware.before()
        }
        #####    
        $response = $kernel->handle($request);
        #####
        foreach(middleware_arr as middleware){
            middleware.after()
        }
    }
    

    虽然有点老土,但是的确解决了问题。但是这个还存在一个问题,就是我们怎么向中间件传递参数的问题,那么如下可以吗:

    $request = Illuminate\Http\Request::capture()
    
    function midware(){
        foreach(middleware_arr as middleware){
           middleware.before($request)
        }
        #####    
        $response = $kernel->handle($request);
        #####
        foreach(middleware_arr as middleware){
            middleware.after($response)
        }
    }
    

    看似是解决了问题,但是仔细分析,就会发现,这里面每次给中间件的都是最初的$request,这显然不行,修改成如下:

    $request = Illuminate\Http\Request::capture()
    
    function midware(){
        foreach(middleware_arr as middleware){
           $request = middleware.before($request)
        }
        #####    
        $response = $kernel->handle($request);
        #####
        foreach(middleware_arr as middleware){
            $response = middleware.after($response)
        }
    }
    

    还有一个问题就是,假设有两个中间件A和B,那么执行顺序应该是怎么样呢:

    $request = Illuminate\Http\Request::capture()
    $request = A.before($request);
    $request = B.before($request);
    
    $response = $kernel->handle($request);
    
    $response = A.after();
    $response = B.after();
    

    这样合理吗?不太好分辨,我们假设有一个记录请求和响应日志的中间件,这个时候,不论你把它放在什么位置,都不能完美的记录最初请求和最终日志。难道类似情况要写两个类,一个记录请求放在中间件数组第一个,一个处理响应,放在数组最后一位吗?不如在执行后面的foreach之前把middleware_arr数组给反转一下,这样就符合了要求:

    $request = Illuminate\Http\Request::capture()
    $request = A.before($request);
    $request = B.before($request);
    
    $response = $kernel->handle($request);
    
    $response = B.after();
    $response = A.after();
    
    

    但是我也开始怀疑这个老土且不灵活的方案是否有更好的解决办法,在观察这个执行顺序的时候,发现是一个包裹样式(洋葱式)的。那个接下来的问题就能不能找到更灵活精美的解决方案,看上面这种结构,总感觉有点熟悉,他很像是A的函数包裹B的函数,B的函数包括了最初的执行代码。函数内部调用函数容易,但是咱们这里每一个中间件之间是不知道对方存在的,所以要把其他中间件要执行的函数传递到上一级,这里就用到了闭包函数还有一个php函数array_reduce(),

    array_reduce函数定义:mixed array_reduce ( array $input , callable $function [, mixed $initial = NULL ] )

    <?php
     function  rsum ( $v ,  $w )
    {
         $v  +=  $w ;
        return  $v ;
    }
    
    function  rmul ( $v ,  $w )
    {
         $v  *=  $w ;
        return  $v ;
    }
    
     $a  = array( 1 ,  2 ,  3 ,  4 ,  5 );
     $x  = array();
     $b  =  array_reduce ( $a ,  "rsum" );
     $c  =  array_reduce ( $a ,  "rmul" ,  10 );
     ?>   
    
    #输出:
    这将使 $b  的值为 15$c  的值为 1200= 10*1*2*3*4*5

    array_reduce() 将回调函数 function 迭代地作用到 input 数组中的每一个单元中,从而将数组简化为单一的值。咱们是把多个函数包裹成最终调用一个函数。

    #我们先假设只有一个middleware,叫log来简化情况,这里的类应该是一个类全路径,我这里就简单的写一下,要不然太长了。
        $middleware_arr = ['log'];
    #最终要执行的代码先封装成一个闭包,要不然没有办法传递到内层,如果用函数名传递函数的话,是没有办法传递参数的。
        $default = function() use($request){
            return $kernel->handle($request);
        }
        $callback = array_reduce($middleware_arr,function($stack,$pipe) {
            return function() use($stack,$pipe){
              return $pipe::handle($stack);
            };
        },$default);
        
        
    # 这里 callback最终是 这样一个函数:
        function() use($default,$log){
              return $log::handle($default);
            };
            
    #所以每一个中间件都需要有一个方法handle方法,方法中要对传输的函数进行运行,类似如下,这里我类名就不大写了
        class log implements Milldeware {
            public static function handle(Closure $func)
            {
                $func();
            }
        }
        
    #这里不难看出可以加入中间件自身逻辑如下:
     class log implements Milldeware {
            public static function handle(Closure $func)
            {
                #这里可以运行逻辑块before()
                $func();
                #这里可以运行逻辑块after()
            }
        }
    

    这样在执行callback函数的时候,执行顺序如下:

    1. 先运行log::haddle()方法,
    2. 执行了log::before()方法
    3. 运行default方法,执行kernel>handle(kernel->handle(request)
    4. 运行log::after()方法

    然后模拟多个的情况如下:

        $middleware_arr = ['csrf','log'];
    #最终要执行的代码先封装成一个闭包,要不然没有办法传递到内层,如果用函数名传递函数的话,是没有办法传递参数的。
        $default = function() use($request){
            return $kernel->handle($request);
        }
        $callback = array_reduce($middleware_arr,function($stack,$pipe) {
            return function() use($stack,$pipe){
              return $pipe::handle($stack);
            };
        },$default);
        
        
    # 这里 callback最终是 执行这样:
    
        $log::handle(function() use($default,$csrf){
                        return $csrf::handle($default);
                    });
    
    

    执行顺序如下:

    1. 先运行log::haddle(包含csrf::handle闭包函数)方法,
    2. 执行了log::before()方法
    3. 运行闭包也就是运行了csrf::handle(csrf::handle(default)
    4. 执行了csrf::before()方法
    5. 运行default方法,执行kernel>handle(kernel->handle(request)
    6. 执行了csrf::after()方法
    7. 运行log::after()方法

    注意这里还有一个问题就是中间件产生的结果,并没有进行传递,可以通过修改共有资源的方式来达到相同的目的,并非需要真的传值到下一个中间件。

    到此这篇文件就结束了,其实其中很多关节都是我写这篇文章的时候才想明白的。尤其是对闭包函数的运用和理解更深了,闭包函数可以延迟利用资源,比如当前不适合执行的语句,又要传递到后面,利用闭包可以封装起来传递出去,这是传统函数做不到的。

    展开全文
  • Laravel中间件原理

    2021-03-01 19:15:17
    在上一篇文章中介绍过 Laravel 的生命周期,这也算是对Laravel 框架入门的一些了解,...创建中间件 array_reduce 函数 中间件源码分析 什么是中间件 中间件在很多框架中有所应用,提供了一种机制方便过滤进入 HT

    在上一篇文章中介绍过 Laravel 的生命周期,这也算是对Laravel 框架入门的一些了解,最近几天也继续探究了下 Laravel 的中间件,出于好奇于是通过查看源码和阅读几篇深度好文,也是对 Laravel 的中间件有了深刻的印象,本篇文章比较长建议结合 IDE 参照源码进行理解。
    PS:喜欢的朋友可以关注公众号:苏小怪的梦呓

    目录

    • 什么是中间件

    • 创建中间件

    • array_reduce 函数

    • 中间件源码分析

    什么是中间件

    中间件在很多框架中有所应用,提供了一种机制方便过滤进入 HTTP 的一些请求。

    在 Laravel 中:Request -> Middleware -> Middleware等 -> Response

    创建中间件

    1、生成中间键类:php artisan make:middleware XXX

    2、编写代码,在中间件类的 handle 方法中实现前置中间件 return $next($request)之前 或者后置中间件return $next($request)之后

    3、注册中间件:在app/Http/Kernel.php 中注册一个中间件

    array_reduce 函数

    因为在源码中用到了 array_reduce 函数,所以先了解它的具体用法,方便后续理解。

    // array_reduce — 用回调函数迭代地将数组简化为单一的值
    mixed array_reduce( array $input, callable $function[, mixed $initial = NULL] )
    // array_reduce() 将回调函数 function 迭代地作用到 input 数组中的每一个单元中,从而将数组简化为单一的值。 
    
    ## 参数
        input 需要迭代的数组
        
        $function 回调函数
        
        initial 如果指定了可选参数 initial,该参数将被当成是数组中的第一个值来处理,或者如果数组为空的话就作为最终返回值。    
    

    array_reduce 函数举例1:

    $arr = ['aaa', 'bbb', 'ccc'];
    $res = array_reduce($arr, function($carry, $piple){
        return $carry.$piple;
    });
    /*
    结果:
    1、第一次迭代:$carry=null,$piple='aaa',返回'aaa'
    2、第二次迭代:$carry='aaa'.$piple='bbb',返回'aaabbb'
    2、第二次迭代:$carry='aaabbb'.$piple='ccc',返回'aaabbbccc'
    */
        
    

    array_reduce 函数举例2(带初始值情况):

    $arr = ['aaa', 'bbb', 'ccc'];
    $res = array_reduce($arr, function($carry, $piple){
        return $carry.$piple;
    }, '初始值-');
    /*
    结果:
    1、第一次迭代:$carry='初始值-',$piple='aaa',返回'初始值-aaa'
    2、第二次迭代:$carry='初始值-aaa'.$piple='bbb',返回'初始值-aaabbb'
    2、第二次迭代:$carry='初始值-aaabbb'.$piple='ccc',返回'初始值-aaabbbccc'
    */
    

    源码分析

    有关于中间件的执行逻辑是从 public/index.php 的 handle 开始,进入 handle 方法 的

    // 处理请求
    $response = $kernel->handle(
        // 创建请求实例
        $request = Illuminate\Http\Request::capture()
    );
    

    一个细节可以让你很好的理解为什么注册中间件需要在 app/Http/Kernel.php 中修改相关参数。

    在 app/Http/Kernel.php 中查看源码可以看到 app/Http/Kernel.php 这个文件的类继承 Illuminate/Foundation/Http/Kernel.php ,所以在 app/Http/Kernel.php 中注册的中间件将会在父类中处理。

    // lluminate/Foundation/Http/Kernel.php 
    protected $middleware = [];
    protected $middlewareGroups = [];
    protected $routeMiddleware = [];
    

    接着查看,vendor/laravel/framework/src/Illuminate/Foundation/Http/Kernel.php 的 handle 方法的sendRequestThroughRouter

    // $response = $this->sendRequestThroughRouter($request);
    
    protected function sendRequestThroughRouter($request)
    {
        $this->app->instance('request', $request);
    
        Facade::clearResolvedInstance('request');
    
        $this->bootstrap();
        
        //这里之后就会去处理中间件
        return (new Pipeline($this->app))
            ->send($request)
            ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
            ->then($this->dispatchToRouter());
    }
    
    

    处理中间件:

    1、构造 Illuminate\Routing\Pipeline 实例

    2、将请求实例 $request 赋值给 Pipeline 的 passable 属性

    3、在 through 方法中判断是否启用中间件(默认启用),启用的话则将全局中间件数组 $middleware 赋值到 Pipeline$pipes 属性

    4、调用 then 其中 dispatchToRouter 返回一个闭包函数,这个闭包函数将在处理完全局中间件逻辑后执行。

    Illuminate/Pipeline/Pipeline.php 的send方法、through 方法

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

    Illuminate/Pipeline/Pipeline.php 的 then方法

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

    分析 then 方法:

    调用 array_reduce 进行预处理,array_reverse($this->pipes) 指的是倒序的待处理的全局中间件数组。

    $this->carry() : 返回的是回调函数。

    // Illuminate/Routing/Pipeline
    protected function carry()
    {
        return function ($stack, $pipe) {
            return function ($passable) use ($stack, $pipe) {
                try {
                    $slice = parent::carry();
                    $callable = $slice($stack, $pipe);
                    return $callable($passable);
                } catch (Exception $e) {
                    return $this->handleException($passable, $e);
                } catch (Throwable $e) {
                    return $this->handleException($passable, new FatalThrowableError($e));
                }
            };
        };
    }
    

    $this->prepareDestination($destination) 是 carry 函数中 $stack 的初始值,该函数返回的也是闭包函数,传入的闭包参数 $destination$this->dispatchToRouter() 返回的闭包函数,其中包含了路由和中间件的匹配和执行 的相关逻辑。

    // Illuminate/Routing/Pipeline 文件中
    protected function prepareDestination(Closure $destination)
    {
        return function ($passable) use ($destination) {
            try {
                return $destination($passable);
            } catch (Exception $e) {
                return $this->handleException($passable, $e);
            } catch (Throwable $e) {
                return $this->handleException($passable, new FatalThrowableError($e));
            }
        };
    }
    

    当用 array_reduce 遍历完所有的 pipe 后,因为 carry 返回的是闭包函数,所以现在也未能执行中间件的 handle 方法 ,

    以下代码是将所有全局中间件和路由处理通过统一的闭包函数进行迭代调用。最终返回的 $pipeline 是一个闭包函数:

    // carry 方法中返回
    return function ($stack, $pipe) {
        return function ($passable) use ($stack, $pipe) {
            try {
                $slice = parent::carry();
    
                $callable = $slice($stack, $pipe);
    
                return $callable($passable);
            } catch (Exception $e) {
                return $this->handleException($passable, $e);
            } catch (Throwable $e) {
                return $this->handleException($passable, new FatalThrowableError($e));
            }
        };
    };
    

    $pipe 的值是全局中间件的第一个值,$stack 代表之前迭代的所有全局中间件和路由处理闭包

    当代码执行到 then 方法的 return $pipeline($this->passable); 时才开始执行以下片段:

    return function ($passable) use ($stack, $pipe) {
        try {
            $slice = parent::carry();
    
            $callable = $slice($stack, $pipe);
    
            return $callable($passable);
        } catch (Exception $e) {
            return $this->handleException($passable, $e);
        } catch (Throwable $e) {
            return $this->handleException($passable, new FatalThrowableError($e));
        }
    };
    

    其中 $passable 为当前的请求实例 $request$stack$pipe 则为 array_reduce 处理后的变量,上述代码中调用了父类的 carry 方法:

    
    protected function carry()
    {
        return function ($stack, $pipe) {
            return function ($passable) use ($stack, $pipe) {
                if (is_callable($pipe)) {
                    return $pipe($passable, $stack);
                } elseif (! is_object($pipe)) {
                    [$name, $parameters] = $this->parsePipeString($pipe);
                    $pipe = $this->getContainer()->make($name);
                    $parameters = array_merge([$passable, $stack], $parameters);
                } else {
                    $parameters = [$passable, $stack];
                }
                $response = method_exists($pipe, $this->method)
                    ? $pipe->{$this->method}(...$parameters)
                : $pipe(...$parameters);
                return $response instanceof Responsable
                    ? $response->toResponse($this->getContainer()->make(Request::class))
                    : $response;
            };
        };
    }
    

    当前迭代的 $pipe 是闭包的话,直接执行并返回;如果$pipe 是对象的话,则实例化该对象并且解析出中间件参数,然后调用对象实例的 handle 方法处理相应的业务逻辑并且返回$response ,最后判断返回的$response 是否为Responsable实例,如果是的话直接返回HTTP响应到客户端,否则继续处理后续的中间件。

    当迭代到最后一个全局中间件时,请求进入$this->prepareDestination 中返回的闭包函数 return $destination($passable);

    protected function prepareDestination(Closure $destination)
    {
        return function ($passable) use ($destination) {
            return $destination($passable);
        };
    }
    
    prepareDestination 返回的是一个匿名函数,调用 prepareDestination 的时候并没有真正执行这个匿名函数( $destination($passable) )
    

    通过代码来源发现最终执行的是:Illuminate\Foundation\Http\Kernel.php中的 dispatchToRouter方法返回的闭包函数:

    function ($request) {
        $this->app->instance('request', $request);
    
        return $this->router->dispatch($request);
    };
    

    其中 dispatch 方法如下:

    // Illuminate\Routing\Router.php 文件内
    public function dispatch(Request $request)
    {
        $this->currentRequest = $request;
    
        return $this->dispatchToRoute($request);
    }
    

    dispatchToRoute 执行的业务逻辑如下:

    // Illuminate\Routing\Router.php 文件内
    public function dispatchToRoute(Request $request)
    {
        return $this->runRoute($request, $this->findRoute($request));
    }
    

    首先根据 通过 findRoute 方法根据当前的请求匹配出对应的路由定义,路由定义中包含中间件等信息(若不存在路由定义,则返回404错误),接着执行 runRoute 方法:

    // 返回给定路由的响应。
    protected function runRoute(Request $request, Route $route)
    {
        $request->setRouteResolver(function () use ($route) {
            return $route;
        });
    
        $this->events->dispatch(new Events\RouteMatched($route, $request));
    
        return $this->prepareResponse($request,
                                      $this->runRouteWithinStack($route, $request)
                                     );
    }
    

    runRoute 中根据请求和路由定义的信息,去执行相应的闭包函数或者控制器方法。

    核心函数 runRouteWithinStack:

    protected function runRouteWithinStack(Route $route, Request $request)
    {
        $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
            $this->container->make('middleware.disable') === true;
    
        $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
    
        return (new Pipeline($this->container))
            ->send($request)
            ->through($middleware)
            ->then(function ($request) use ($route) {
                return $this->prepareResponse(
                    $request, $route->run()
                );
            });
    }
    

    通过 middleware.disable 判断是否禁用了 Laravel 中间件,如果禁用了则返回空数组,否则通过 gatherRouteMiddleware 从路由定义中收集中间件信息,并且按照优先级对中间件进行排序,然后调用 Kernel 中类似的代码对路由中间件进行处理,逻辑和前面的全局中间件类似,如果全部中间件校验通过,则传入闭包中的逻辑:

    return $this->prepareResponse(
        $request, $route->run()
    );
    

    准备好响应数据

    接着来到 public/index.php 中的 $response->send(); 将响应数据返回给客户端

    最后是 terminate 逻辑的调用,Laravel 中间件会检查全局中间件和路由中间件中是否包含 trminate 方法,如果包含的话则认为改中间件为 终端中间件,并执行其中的 terminate 方法。

    terminate 中间件对应的底层代码如下:

    protected function terminateMiddleware($request, $response)
    {
        $middlewares = $this->app->shouldSkipMiddleware() ? [] : array_merge(
            $this->gatherRouteMiddleware($request),
            $this->middleware
        );
    
        foreach ($middlewares as $middleware) {
            if (! is_string($middleware)) {
                continue;
            }
    
            [$name] = $this->parseMiddleware($middleware);
    
            $instance = $this->app->make($name);
    
            if (method_exists($instance, 'terminate')) {
                $instance->terminate($request, $response);
            }
        }
    }
    
    展开全文
  • Laravel中间件

    2019-03-28 16:08:22
    一.什么是中间件? 一个请求可以通过路由分配到某个控制器上然后进行处理,如果...怎么创建中间件 php artisan make:middleware AdminAuthMiddleware //此命令将会在 app/Http/Middleware 目录内创建一个名称为 Ad...

    一.什么是中间件?
    一个请求可以通过路由分配到某个控制器上然后进行处理,如果我们想对请求加一个限制,只允许某些请求能够到达控制器,而过滤掉我们不想要的请求,这时候就可以使用 Laravel 的中间件
    二.怎么创建中间件
    php artisan make:middleware AdminAuthMiddleware
    //此命令将会在 app/Http/Middleware 目录内创建一个名称为 AdminAuthMiddleware 的中间件。
    //这时候我们将在AdminAuthMiddleware这个类中看到handle方法,在这个方法里我们就可以写这个中间件执行的内容。
    在这里插入图片描述
    三.注册中间件
    打开 app/Http/Kernel.php文件
    在这里插入图片描述
    四.使用中间件
    打开web文件
    在这里插入图片描述

    OK了

    展开全文
  • laravel 创建自定义中间件

    千次阅读 2018-12-15 17:43:24
    这个命令会在 app/Http/Middleware 目录下创建一个新的中间件类 LoginMiddleware.php 我这里是判断session里是否有值,如果没有值,则重定向到登陆界面,让用户重新登录,无法访问。右侧方框里可以写自己的逻辑...
  • 运行Artisan 命令 make:middleware 创建中间件:php artisan make:middleware CheckAge中间件创建完成后还需要注册中间件.全局中间件:所有的路由都会生效在 app/Http/Kernel.php 中的 $middleware 数组中...
  • laravel 登录中间件

    2020-10-29 16:52:16
    创建中间件 php artisan make:middleware 中间件名称 绑定路由中间件 绑到指定的路由 给路由分组绑定 在控制器中绑定 中间件传参 获取中间件传过来参数 实现后台用户防翻墙 实现后台用户防翻墙 ...
  • laravel跨域中间件

    2020-03-07 09:44:55
    创建中间件 DOS php artisan make:middleware Cross 在 app\Http\MiddleWare 创建 Cross.php 文件 <?php namespace App\Http\Middleware; use Closure; class Cross { /** * Handle an incoming ...
  • laravel 5.5 中间件

    2020-08-30 01:06:42
    1.创建中间件 php artisan make:middleware App\Modules\Admin\Http\Middleware\IsLogin 内容 修改如下 <?php namespace App\Modules\Admin\Http\Middleware; use Closure; class IsLogin { /** * ...
  • Laravel中间件

    2019-09-21 20:02:18
    1、创建中间件: php artisan make:middleware CheckBackendLogin 会在application/http/middleware下生成Check.php中间件,我们编辑内容。 —— 以下例子属于后执行中间件,就是各种条件都不满足,才会...
  • Laravel中间件可以方便的过滤进入我们网页的请求。包括用户授权,CORS来指定流出请求的header等。 定义一个新的中间件可以使用命令: php artisan make:middleware AgeMiddleware 这条命令在app/...
  • Laravel 中间件是什么? 简而言之,中间件laravel 中的作用就是过滤 HTTP 请求,根据不同的请求来执行不同的逻辑操作。 我们可以通过中间件实现以下功能: 指定某些路由 设置 HTTP 响应头 记录请求 过滤请求的...
  • Laravel middleware中间件

    2020-05-16 09:38:00
    创建 php artisan make:middleware TestMiddleware 自动生成了 app/Http/Middleware/TestMiddleware.php 文件 public function handle($request, Closure $next) { //编写具体业务 if($request->get("id")==...
  • Laravel——中间件

    2019-05-18 21:13:19
    1.找到对应的项目路径,配置好环境变量,执行artisan命令 ... 2.在合适的位置,存储 session 值,释放 session 值 session(['number' => $input['number']]);...3.在目录中可以看到创建好的文件 4....
  • Laravel使用中间件记录用户请求日志

    千次阅读 2021-03-28 02:19:19
    一、创建中间件 可以使用命令创建, 也可以直接创建 php artisan make:middleware 中间件名称(TraceRecordMiddleware) 二、注册中间件 因为不同版本的laravel注册中间价的方式不同, 这里以5.6版本为例 直接在...
  • 步骤: 1、创建中间件,中间件的定义采用大驼峰命名 2、app/Http/Kernel.php中注册中间件 3、路由中使用中间件做http过滤拦截 4、重启swoole进程(作为web的http服务) 参考文档: ...
  • Laravel5.6 中间件使用

    2018-09-01 22:23:36
    创建中间件 php artisan make:middleware [middleware name] 编写中间件代码 &lt;?php namespace App\Http\Middleware; use Closure; class Test { /** * Handle an incoming request. * * @...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 261
精华内容 104
关键字:

laravel创建中间件