Analyse von Ideen zur Erstellung von Laravel-Middleware

Es gibt viele Implementierungsprinzipien für das Parsen von Laravel-Middleware im Internet, aber ich frage mich, ob es Leser gibt, die es beim Lesen nicht verstanden haben. Wie kam der Autor auf die Idee, die Funktion array_reduce zu verwenden?

Empfohlen: Laravel-Tutorial

Dieser Artikel beginnt aus meiner eigenen Perspektive und simuliert, wie ich diese Middleware-Funktion implementieren würde, wenn ich der Autor wäre, und wie sie sie findet und verwendet die entsprechende Funktion.

Was ist Laravel-Middleware?

Laravel-Middleware bietet einen Mechanismus, um den ursprünglichen Programmfluss zu unterbrechen, ohne den Logikcode zu ändern, und einige Ereignisse über Middleware zu verarbeiten oder einige Funktionen zu erweitern . Protokollierungs-Middleware kann beispielsweise problemlos Anforderungs- und Antwortprotokolle aufzeichnen, ohne den Logikcode zu ändern.

Dann vereinfachen wir den Software-Ausführungsprozess. Jetzt gibt es einen Kernel der Klasse und das Folgende ist sein Laravel-Code

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

Die Funktion des Codes besteht darin, eine Anfrage zu erfassen und eine Antwort zurückzugeben . Hier handelt es sich um das Codesegment, das anschließend an die spezifische Ausführungslogik verteilt wird und die Ergebnisse zurückgibt.

Wenn Sie also vor oder nach der Ausführung der Methode $kernel->handle() ein Stück Logik hinzufügen möchten, wie würden Sie es schreiben? Es ist ungefähr wie folgt:

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

Natürlich gibt es kein Problem mit dem Schreiben auf diese Weise, aber es gibt keine Skalierbarkeit. Sie müssen diese Methode ändern, um etwas auszuführen. Es ist unmöglich, sie in den Kerninhalt einzukapseln Rahmen. Wie kann man es verbessern?

Definieren Sie eine auszuführende Middleware-Klasse namens Middleware. Die Klasse implementiert zwei Methoden, before() und after(), und der Code lautet wie folgt.

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

Löst es das Problem, ohne es zu ändern? Aber was ist, wenn wir mehrere Middlewares benötigen? Definieren Sie ein Middleware-Array middleware_arr, das beide vor und enthält Nach Methoden. Der Code lautet wie folgt:

#配置项中有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()
    }
}

Obwohl es etwas altmodisch ist, löst es das Problem. Aber es gibt immer noch ein Problem, das heißt, wie übergeben wir Parameter an die Middleware? Ist das wie folgt in Ordnung:

$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)
    }
}

Es scheint das Problem zu lösen, aber wenn Sie es sorgfältig analysieren, werden Sie es tun Stellen Sie fest, dass die Middleware jedes Mal die ursprüngliche $-Anfrage ist, was offensichtlich nicht funktioniert. Ändern Sie sie wie folgt:

$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)
    }
}

Eine andere Frage ist, was sollte, vorausgesetzt, es gibt zwei Middlewares A und B sei die Ausführungsreihenfolge:

rrree

Ist das vernünftig? Nehmen wir an, dass es eine Middleware gibt, die Anforderungs- und Antwortprotokolle aufzeichnet, egal wo Sie sie ablegen Zeichnen Sie die erste Anfrage und das letzte Protokoll auf. Ist es in einer ähnlichen Situation notwendig, zwei Klassen zu schreiben, eine zum Aufzeichnen der Anfrage und zum Platzieren an erster Stelle im Middleware-Array und eine zum Verarbeiten der Antwort und zum Platzieren an der letzten Stelle im Array? Es ist besser, das middleware_arr-Array vor der Ausführung von foreach umzukehren, damit es die Anforderungen erfüllt:

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

Aber ich begann mich auch zu fragen, ob es eine bessere Lösung für diese altmodische und unflexible Lösung gibt Als wir diese Ausführungssequenz beobachteten, stellten wir fest, dass es sich um einen Wrapper-Stil (Zwiebelstil) handelt. Können wir eine flexiblere und elegantere Lösung für das nächste Problem finden? Wenn wir uns die obige Struktur ansehen, kommt es uns immer ein wenig bekannt vor. Sie ähnelt der Funktion von A, die die Funktion von B umschließt, und die Funktion von B enthält den anfänglichen Ausführungscode. Es ist einfach, Funktionen innerhalb einer Funktion aufzurufen, aber jede Middleware kennt hier nicht die Existenz der anderen, daher müssen die von anderen Middleware auszuführenden Funktionen an die obere Ebene übergeben werden. Hier sind eine Abschlussfunktion und eine PHP-Funktion verwendet. array_reduce(),

array_reduce-Funktionsdefinition: gemischt array_reduce ( array $input , callable $function [, Mixed $initial = NULL ] )

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

array_reduce() wird auf den Rückruf reagieren Funktion iterativ für jede Zelle im Eingabearray, wodurch das Array auf einen einzelnen Wert reduziert wird. Wir verpacken mehrere Funktionen in einer Funktion, die letztendlich aufgerufen wird.

<?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）

Auf diese Weise ist beim Ausführen der Rückruffunktion die Ausführungssequenz wie folgt:

führt zuerst die Methode log::haddle() aus und

führt die aus log::before()-Methode

Führen Sie die Standardmethode aus, führen Sie $kernel->handle($request) aus

Führen Sie die log::after()-Methode aus

und simulieren Sie dann mehrere Situationen wie folgt:

#我们先假设只有一个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()
        }
    }

Die Ausführungssequenz ist wie folgt:

1 Führen Sie zuerst die Methode log::haddle (einschließlich csrf::handle-Abschlussfunktion) aus,

2. Log::before ()-Methode ausführen

3. Das Ausführen des Abschlusses bedeutet, dass $csrf::handle($default) ausgeführt wird.

4 ()-Methode

5. Führen Sie die Standardmethode aus und führen Sie $kernel->handle($request) aus

6. Führen Sie die csrf::after()-Methode aus

7. Führen Sie die Methode log::after() aus. Beachten Sie, dass ein weiteres Problem darin besteht, dass die von der Middleware generierten Ergebnisse nicht weitergegeben werden. Derselbe Zweck kann durch Ändern der gemeinsam genutzten Ressourcen erreicht werden notwendig, um den Wert tatsächlich an die nächste Middleware weiterzugeben.

Dies ist das Ende dieses Dokuments. Tatsächlich wurden viele der Verbindungen erst herausgefunden, als ich diesen Artikel schrieb. Insbesondere habe ich ein tieferes Verständnis für die Verwendung und das Verständnis von Schließungsfunktionen, die die Verwendung von Ressourcen verzögern können. Beispielsweise müssen Schließungen zur Kapselung verwendet werden Dies ist etwas, was herkömmliche Funktionen nicht leisten können.

Das obige ist der detaillierte Inhalt vonAnalyse von Ideen zur Erstellung von Laravel-Middleware. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!